onasty: cmd/api/main.go (d4cfa0b7a2d8f751426feb4210534dc907302ad1)

1

package main

2

3

import (

4

	"context"

5

	"errors"

6

	"fmt"

7

	"log/slog"

8

	"net/http"

9

	"os"

10

	"os/signal"

11

12

	"github.com/gin-gonic/gin"

13

	"github.com/nats-io/nats.go"

14

	"github.com/olexsmir/onasty/internal/config"

15

	"github.com/olexsmir/onasty/internal/events/mailermq"

16

	"github.com/olexsmir/onasty/internal/hasher"

17

	"github.com/olexsmir/onasty/internal/jwtutil"

18

	"github.com/olexsmir/onasty/internal/logger"

19

	"github.com/olexsmir/onasty/internal/metrics"

20

	"github.com/olexsmir/onasty/internal/oauth"

21

	"github.com/olexsmir/onasty/internal/service/notesrv"

22

	"github.com/olexsmir/onasty/internal/service/usersrv"

23

	"github.com/olexsmir/onasty/internal/store/psql/noterepo"

24

	"github.com/olexsmir/onasty/internal/store/psql/passwordtokrepo"

25

	"github.com/olexsmir/onasty/internal/store/psql/sessionrepo"

26

	"github.com/olexsmir/onasty/internal/store/psql/userepo"

27

	"github.com/olexsmir/onasty/internal/store/psql/vertokrepo"

28

	"github.com/olexsmir/onasty/internal/store/psqlutil"

29

	"github.com/olexsmir/onasty/internal/store/rdb"

30

	"github.com/olexsmir/onasty/internal/store/rdb/notecache"

31

	"github.com/olexsmir/onasty/internal/store/rdb/usercache"

32

	httptransport "github.com/olexsmir/onasty/internal/transport/http"

33

	"github.com/olexsmir/onasty/internal/transport/http/httpserver"

34

	"github.com/olexsmir/onasty/internal/transport/http/ratelimit"

35

36

37

func main() {

38

	if err := run(context.Background()); err != nil {

39

		fmt.Fprintf(os.Stderr, "error: %v\n", err)

40

		os.Exit(1)

41

42

43

44

//nolint:err113,funlen

45

func run(ctx context.Context) error {

46

	ctx, cancel := context.WithCancel(ctx)

47

	defer cancel()

48

49

	cfg := config.NewConfig()

50

51

	// logger

52

	if err := logger.SetDefault(cfg.LogLevel, cfg.LogFormat, cfg.LogShowLine); err != nil {

53

		return err

54

55

56

	// semi dev mode

57

	if !cfg.AppEnv.IsDevMode() {

58

		gin.SetMode(gin.ReleaseMode)

59

60

61

	// app deps

62

	nc, err := nats.Connect(cfg.NatsURL)

63

	if err != nil {

64

		return err

65

66

67

	psqlDB, err := psqlutil.Connect(ctx, cfg.PostgresDSN)

68

	if err != nil {

69

		return err

70

71

72

	redisDB, err := rdb.Connect(ctx, cfg.RedisAddr, cfg.RedisPassword, cfg.RedisDB)

73

	if err != nil {

74

		return err

75

76

77

	userPasswordHasher := hasher.NewSHA256Hasher(cfg.PasswordSalt)

78

	notePasswordHasher := hasher.NewSHA256Hasher(cfg.NotePasswordSalt)

79

	jwtTokenizer := jwtutil.NewJWTUtil(cfg.JwtSigningKey, cfg.JwtAccessTokenTTL)

80

81

	googleOauth := oauth.NewGoogleProvider(

82

		cfg.GoogleClientID,

83

		cfg.GoogleSecret,

84

		cfg.GoogleRedirectURL,

85

86

	githubOauth := oauth.NewGithubProvider(

87

		cfg.GitHubClientID,

88

		cfg.GitHubSecret,

89

		cfg.GitHubRedirectURL,

90

91

92

	mailermq := mailermq.New(nc)

93

94

	sessionrepo := sessionrepo.New(psqlDB)

95

	vertokrepo := vertokrepo.New(psqlDB)

96

	pwdtokrepo := passwordtokrepo.NewPasswordResetTokenRepo(psqlDB)

97

98

	userepo := userepo.New(psqlDB)

99

	usercache := usercache.New(redisDB, cfg.CacheUsersTTL)

100

	usersrv := usersrv.New(

101

		userepo,

102

		sessionrepo,

103

		vertokrepo,

104

		pwdtokrepo,

105

		userPasswordHasher,

106

		jwtTokenizer,

107

		mailermq,

108

		usercache,

109

		googleOauth,

110

		githubOauth,

111

		cfg.JwtRefreshTokenTTL,

112

		cfg.VerificationTokenTTL,

113

		cfg.ResetPasswordTokenTTL,

114

115

116

	notecache := notecache.New(redisDB, cfg.CacheNoteTTL)

117

	noterepo := noterepo.New(psqlDB)

118

	notesrv := notesrv.New(noterepo, notePasswordHasher, notecache)

119

120

	rateLimiterConfig := ratelimit.Config{

121

		RPS:   cfg.RateLimiterRPS,

122

		TTL:   cfg.RateLimiterTTL,

123

		Burst: cfg.RateLimiterBurst,

124

125

126

	handler := httptransport.NewTransport(

127

		usersrv,

128

		notesrv,

129

		cfg.AppEnv,

130

		cfg.AppURL,

131

		cfg.CORSAllowedOrigins,

132

		cfg.CORSMaxAge,

133

		rateLimiterConfig,

134

135

136

	// http server

137

	srv := httpserver.NewServer(handler.Handler(), httpserver.Config{

138

		Port:            cfg.HTTPPort,

139

		ReadTimeout:     cfg.HTTPReadTimeout,

140

		WriteTimeout:    cfg.HTTPWriteTimeout,

141

		MaxHeaderSizeMb: cfg.HTTPHeaderMaxSizeMb,

142

})

143

	go func() {

144

		slog.Info("starting http server", "port", cfg.HTTPPort)

145

		if err := srv.Start(); !errors.Is(err, http.ErrServerClosed) {

146

			slog.Error("failed to start http server", "error", err)

147

148

}()

149

150

	// metrics

151

	if cfg.MetricsEnabled {

152

		mSrv := httpserver.NewDefaultServer(metrics.Handler(), cfg.MetricsPort)

153

		go func() {

154

			slog.Info("starting metrics server", "port", cfg.MetricsPort)

155

			if err := mSrv.Start(); !errors.Is(err, http.ErrServerClosed) {

156

				slog.Error("failed to start metrics server", "error", err)

157

158

}()

159

160

161

	// graceful shutdown

162

	quitCh := make(chan os.Signal, 1)

163

	signal.Notify(quitCh, os.Interrupt)

164

	<-quitCh

165

166

	if err := srv.Stop(ctx); err != nil {

167

		return errors.Join(errors.New("failed to stop http server"), err)

168

169

170

	if err := psqlDB.Close(); err != nil {

171

		return errors.Join(errors.New("failed to close postgres connection"), err)

172

173

174

	if err := redisDB.Close(); err != nil {

175

		return errors.Join(errors.New("failed to close redis connection"), err)

176

177

178

	return nil

179

1	package main
2
3	import (
4	"context"
5	"errors"
6	"fmt"
7	"log/slog"
8	"net/http"
9	"os"
10	"os/signal"
11
12	"github.com/gin-gonic/gin"
13	"github.com/nats-io/nats.go"
14	"github.com/olexsmir/onasty/internal/config"
15	"github.com/olexsmir/onasty/internal/events/mailermq"
16	"github.com/olexsmir/onasty/internal/hasher"
17	"github.com/olexsmir/onasty/internal/jwtutil"
18	"github.com/olexsmir/onasty/internal/logger"
19	"github.com/olexsmir/onasty/internal/metrics"
20	"github.com/olexsmir/onasty/internal/oauth"
21	"github.com/olexsmir/onasty/internal/service/notesrv"
22	"github.com/olexsmir/onasty/internal/service/usersrv"
23	"github.com/olexsmir/onasty/internal/store/psql/noterepo"
24	"github.com/olexsmir/onasty/internal/store/psql/passwordtokrepo"
25	"github.com/olexsmir/onasty/internal/store/psql/sessionrepo"
26	"github.com/olexsmir/onasty/internal/store/psql/userepo"
27	"github.com/olexsmir/onasty/internal/store/psql/vertokrepo"
28	"github.com/olexsmir/onasty/internal/store/psqlutil"
29	"github.com/olexsmir/onasty/internal/store/rdb"
30	"github.com/olexsmir/onasty/internal/store/rdb/notecache"
31	"github.com/olexsmir/onasty/internal/store/rdb/usercache"
32	httptransport "github.com/olexsmir/onasty/internal/transport/http"
33	"github.com/olexsmir/onasty/internal/transport/http/httpserver"
34	"github.com/olexsmir/onasty/internal/transport/http/ratelimit"
35	)
36
37	func main() {
38	if err := run(context.Background()); err != nil {
39	fmt.Fprintf(os.Stderr, "error: %v\n", err)
40	os.Exit(1)
41	}
42	}
43
44	//nolint:err113,funlen
45	func run(ctx context.Context) error {
46	ctx, cancel := context.WithCancel(ctx)
47	defer cancel()
48
49	cfg := config.NewConfig()
50
51	// logger
52	if err := logger.SetDefault(cfg.LogLevel, cfg.LogFormat, cfg.LogShowLine); err != nil {
53	return err
54	}
55
56	// semi dev mode
57	if !cfg.AppEnv.IsDevMode() {
58	gin.SetMode(gin.ReleaseMode)
59	}
60
61	// app deps
62	nc, err := nats.Connect(cfg.NatsURL)
63	if err != nil {
64	return err
65	}
66
67	psqlDB, err := psqlutil.Connect(ctx, cfg.PostgresDSN)
68	if err != nil {
69	return err
70	}
71
72	redisDB, err := rdb.Connect(ctx, cfg.RedisAddr, cfg.RedisPassword, cfg.RedisDB)
73	if err != nil {
74	return err
75	}
76
77	userPasswordHasher := hasher.NewSHA256Hasher(cfg.PasswordSalt)
78	notePasswordHasher := hasher.NewSHA256Hasher(cfg.NotePasswordSalt)
79	jwtTokenizer := jwtutil.NewJWTUtil(cfg.JwtSigningKey, cfg.JwtAccessTokenTTL)
80
81	googleOauth := oauth.NewGoogleProvider(
82	cfg.GoogleClientID,
83	cfg.GoogleSecret,
84	cfg.GoogleRedirectURL,
85	)
86	githubOauth := oauth.NewGithubProvider(
87	cfg.GitHubClientID,
88	cfg.GitHubSecret,
89	cfg.GitHubRedirectURL,
90	)
91
92	mailermq := mailermq.New(nc)
93
94	sessionrepo := sessionrepo.New(psqlDB)
95	vertokrepo := vertokrepo.New(psqlDB)
96	pwdtokrepo := passwordtokrepo.NewPasswordResetTokenRepo(psqlDB)
97
98	userepo := userepo.New(psqlDB)
99	usercache := usercache.New(redisDB, cfg.CacheUsersTTL)
100	usersrv := usersrv.New(
101	userepo,
102	sessionrepo,
103	vertokrepo,
104	pwdtokrepo,
105	userPasswordHasher,
106	jwtTokenizer,
107	mailermq,
108	usercache,
109	googleOauth,
110	githubOauth,
111	cfg.JwtRefreshTokenTTL,
112	cfg.VerificationTokenTTL,
113	cfg.ResetPasswordTokenTTL,
114	)
115
116	notecache := notecache.New(redisDB, cfg.CacheNoteTTL)
117	noterepo := noterepo.New(psqlDB)
118	notesrv := notesrv.New(noterepo, notePasswordHasher, notecache)
119
120	rateLimiterConfig := ratelimit.Config{
121	RPS: cfg.RateLimiterRPS,
122	TTL: cfg.RateLimiterTTL,
123	Burst: cfg.RateLimiterBurst,
124	}
125
126	handler := httptransport.NewTransport(
127	usersrv,
128	notesrv,
129	cfg.AppEnv,
130	cfg.AppURL,
131	cfg.CORSAllowedOrigins,
132	cfg.CORSMaxAge,
133	rateLimiterConfig,
134	)
135
136	// http server
137	srv := httpserver.NewServer(handler.Handler(), httpserver.Config{
138	Port: cfg.HTTPPort,
139	ReadTimeout: cfg.HTTPReadTimeout,
140	WriteTimeout: cfg.HTTPWriteTimeout,
141	MaxHeaderSizeMb: cfg.HTTPHeaderMaxSizeMb,
142	})
143	go func() {
144	slog.Info("starting http server", "port", cfg.HTTPPort)
145	if err := srv.Start(); !errors.Is(err, http.ErrServerClosed) {
146	slog.Error("failed to start http server", "error", err)
147	}
148	}()
149
150	// metrics
151	if cfg.MetricsEnabled {
152	mSrv := httpserver.NewDefaultServer(metrics.Handler(), cfg.MetricsPort)
153	go func() {
154	slog.Info("starting metrics server", "port", cfg.MetricsPort)
155	if err := mSrv.Start(); !errors.Is(err, http.ErrServerClosed) {
156	slog.Error("failed to start metrics server", "error", err)
157	}
158	}()
159	}
160
161	// graceful shutdown
162	quitCh := make(chan os.Signal, 1)
163	signal.Notify(quitCh, os.Interrupt)
164	<-quitCh
165
166	if err := srv.Stop(ctx); err != nil {
167	return errors.Join(errors.New("failed to stop http server"), err)
168	}
169
170	if err := psqlDB.Close(); err != nil {
171	return errors.Join(errors.New("failed to close postgres connection"), err)
172	}
173
174	if err := redisDB.Close(); err != nil {
175	return errors.Join(errors.New("failed to close redis connection"), err)
176	}
177
178	return nil
179	}