gitea

1
// Copyright 2022 The Gitea Authors. All rights reserved.
2
// SPDX-License-Identifier: MIT
3

4
package cmd
5

6
import (
7
	"errors"
8
	"fmt"
9
	"os"
10

11
	"code.gitea.io/gitea/modules/log"
12
	"code.gitea.io/gitea/modules/private"
13

14
	"github.com/urfave/cli/v2"
15
)
16

17
var (
18
	defaultLoggingFlags = []cli.Flag{
19
		&cli.StringFlag{
20
			Name:  "logger",
21
			Usage: `Logger name - will default to "default"`,
22
		},
23
		&cli.StringFlag{
24
			Name:  "writer",
25
			Usage: "Name of the log writer - will default to mode",
26
		},
27
		&cli.StringFlag{
28
			Name:  "level",
29
			Usage: "Logging level for the new logger",
30
		},
31
		&cli.StringFlag{
32
			Name:    "stacktrace-level",
33
			Aliases: []string{"L"},
34
			Usage:   "Stacktrace logging level",
35
		},
36
		&cli.StringFlag{
37
			Name:    "flags",
38
			Aliases: []string{"F"},
39
			Usage:   "Flags for the logger",
40
		},
41
		&cli.StringFlag{
42
			Name:    "expression",
43
			Aliases: []string{"e"},
44
			Usage:   "Matching expression for the logger",
45
		},
46
		&cli.StringFlag{
47
			Name:    "prefix",
48
			Aliases: []string{"p"},
49
			Usage:   "Prefix for the logger",
50
		},
51
		&cli.BoolFlag{
52
			Name:  "color",
53
			Usage: "Use color in the logs",
54
		},
55
		&cli.BoolFlag{
56
			Name: "debug",
57
		},
58
	}
59

60
	subcmdLogging = &cli.Command{
61
		Name:  "logging",
62
		Usage: "Adjust logging commands",
63
		Subcommands: []*cli.Command{
64
			{
65
				Name:  "pause",
66
				Usage: "Pause logging (Gitea will buffer logs up to a certain point and will drop them after that point)",
67
				Flags: []cli.Flag{
68
					&cli.BoolFlag{
69
						Name: "debug",
70
					},
71
				},
72
				Action: runPauseLogging,
73
			}, {
74
				Name:  "resume",
75
				Usage: "Resume logging",
76
				Flags: []cli.Flag{
77
					&cli.BoolFlag{
78
						Name: "debug",
79
					},
80
				},
81
				Action: runResumeLogging,
82
			}, {
83
				Name:  "release-and-reopen",
84
				Usage: "Cause Gitea to release and re-open files used for logging",
85
				Flags: []cli.Flag{
86
					&cli.BoolFlag{
87
						Name: "debug",
88
					},
89
				},
90
				Action: runReleaseReopenLogging,
91
			}, {
92
				Name:      "remove",
93
				Usage:     "Remove a logger",
94
				ArgsUsage: "[name] Name of logger to remove",
95
				Flags: []cli.Flag{
96
					&cli.BoolFlag{
97
						Name: "debug",
98
					}, &cli.StringFlag{
99
						Name:  "logger",
100
						Usage: `Logger name - will default to "default"`,
101
					},
102
				},
103
				Action: runRemoveLogger,
104
			}, {
105
				Name:  "add",
106
				Usage: "Add a logger",
107
				Subcommands: []*cli.Command{
108
					{
109
						Name:  "file",
110
						Usage: "Add a file logger",
111
						Flags: append(defaultLoggingFlags, []cli.Flag{
112
							&cli.StringFlag{
113
								Name:    "filename",
114
								Aliases: []string{"f"},
115
								Usage:   "Filename for the logger - this must be set.",
116
							},
117
							&cli.BoolFlag{
118
								Name:    "rotate",
119
								Aliases: []string{"r"},
120
								Usage:   "Rotate logs",
121
								Value:   true,
122
							},
123
							&cli.Int64Flag{
124
								Name:    "max-size",
125
								Aliases: []string{"s"},
126
								Usage:   "Maximum size in bytes before rotation",
127
							},
128
							&cli.BoolFlag{
129
								Name:    "daily",
130
								Aliases: []string{"d"},
131
								Usage:   "Rotate logs daily",
132
								Value:   true,
133
							},
134
							&cli.IntFlag{
135
								Name:    "max-days",
136
								Aliases: []string{"D"},
137
								Usage:   "Maximum number of daily logs to keep",
138
							},
139
							&cli.BoolFlag{
140
								Name:    "compress",
141
								Aliases: []string{"z"},
142
								Usage:   "Compress rotated logs",
143
								Value:   true,
144
							},
145
							&cli.IntFlag{
146
								Name:    "compression-level",
147
								Aliases: []string{"Z"},
148
								Usage:   "Compression level to use",
149
							},
150
						}...),
151
						Action: runAddFileLogger,
152
					}, {
153
						Name:  "conn",
154
						Usage: "Add a net conn logger",
155
						Flags: append(defaultLoggingFlags, []cli.Flag{
156
							&cli.BoolFlag{
157
								Name:    "reconnect-on-message",
158
								Aliases: []string{"R"},
159
								Usage:   "Reconnect to host for every message",
160
							},
161
							&cli.BoolFlag{
162
								Name:    "reconnect",
163
								Aliases: []string{"r"},
164
								Usage:   "Reconnect to host when connection is dropped",
165
							},
166
							&cli.StringFlag{
167
								Name:    "protocol",
168
								Aliases: []string{"P"},
169
								Usage:   "Set protocol to use: tcp, unix, or udp (defaults to tcp)",
170
							},
171
							&cli.StringFlag{
172
								Name:    "address",
173
								Aliases: []string{"a"},
174
								Usage:   "Host address and port to connect to (defaults to :7020)",
175
							},
176
						}...),
177
						Action: runAddConnLogger,
178
					},
179
				},
180
			}, {
181
				Name:  "log-sql",
182
				Usage: "Set LogSQL",
183
				Flags: []cli.Flag{
184
					&cli.BoolFlag{
185
						Name: "debug",
186
					},
187
					&cli.BoolFlag{
188
						Name:  "off",
189
						Usage: "Switch off SQL logging",
190
					},
191
				},
192
				Action: runSetLogSQL,
193
			},
194
		},
195
	}
196
)
197

198
func runRemoveLogger(c *cli.Context) error {
199
	ctx, cancel := installSignals()
200
	defer cancel()
201

202
	setup(ctx, c.Bool("debug"))
203
	logger := c.String("logger")
204
	if len(logger) == 0 {
205
		logger = log.DEFAULT
206
	}
207
	writer := c.Args().First()
208

209
	extra := private.RemoveLogger(ctx, logger, writer)
210
	return handleCliResponseExtra(extra)
211
}
212

213
func runAddConnLogger(c *cli.Context) error {
214
	ctx, cancel := installSignals()
215
	defer cancel()
216

217
	setup(ctx, c.Bool("debug"))
218
	vals := map[string]any{}
219
	mode := "conn"
220
	vals["net"] = "tcp"
221
	if c.IsSet("protocol") {
222
		switch c.String("protocol") {
223
		case "udp":
224
			vals["net"] = "udp"
225
		case "unix":
226
			vals["net"] = "unix"
227
		}
228
	}
229
	if c.IsSet("address") {
230
		vals["address"] = c.String("address")
231
	} else {
232
		vals["address"] = ":7020"
233
	}
234
	if c.IsSet("reconnect") {
235
		vals["reconnect"] = c.Bool("reconnect")
236
	}
237
	if c.IsSet("reconnect-on-message") {
238
		vals["reconnectOnMsg"] = c.Bool("reconnect-on-message")
239
	}
240
	return commonAddLogger(c, mode, vals)
241
}
242

243
func runAddFileLogger(c *cli.Context) error {
244
	ctx, cancel := installSignals()
245
	defer cancel()
246

247
	setup(ctx, c.Bool("debug"))
248
	vals := map[string]any{}
249
	mode := "file"
250
	if c.IsSet("filename") {
251
		vals["filename"] = c.String("filename")
252
	} else {
253
		return errors.New("filename must be set when creating a file logger")
254
	}
255
	if c.IsSet("rotate") {
256
		vals["rotate"] = c.Bool("rotate")
257
	}
258
	if c.IsSet("max-size") {
259
		vals["maxsize"] = c.Int64("max-size")
260
	}
261
	if c.IsSet("daily") {
262
		vals["daily"] = c.Bool("daily")
263
	}
264
	if c.IsSet("max-days") {
265
		vals["maxdays"] = c.Int("max-days")
266
	}
267
	if c.IsSet("compress") {
268
		vals["compress"] = c.Bool("compress")
269
	}
270
	if c.IsSet("compression-level") {
271
		vals["compressionLevel"] = c.Int("compression-level")
272
	}
273
	return commonAddLogger(c, mode, vals)
274
}
275

276
func commonAddLogger(c *cli.Context, mode string, vals map[string]any) error {
277
	if len(c.String("level")) > 0 {
278
		vals["level"] = log.LevelFromString(c.String("level")).String()
279
	}
280
	if len(c.String("stacktrace-level")) > 0 {
281
		vals["stacktraceLevel"] = log.LevelFromString(c.String("stacktrace-level")).String()
282
	}
283
	if len(c.String("expression")) > 0 {
284
		vals["expression"] = c.String("expression")
285
	}
286
	if len(c.String("prefix")) > 0 {
287
		vals["prefix"] = c.String("prefix")
288
	}
289
	if len(c.String("flags")) > 0 {
290
		vals["flags"] = log.FlagsFromString(c.String("flags"))
291
	}
292
	if c.IsSet("color") {
293
		vals["colorize"] = c.Bool("color")
294
	}
295
	logger := log.DEFAULT
296
	if c.IsSet("logger") {
297
		logger = c.String("logger")
298
	}
299
	writer := mode
300
	if c.IsSet("writer") {
301
		writer = c.String("writer")
302
	}
303
	ctx, cancel := installSignals()
304
	defer cancel()
305

306
	extra := private.AddLogger(ctx, logger, writer, mode, vals)
307
	return handleCliResponseExtra(extra)
308
}
309

310
func runPauseLogging(c *cli.Context) error {
311
	ctx, cancel := installSignals()
312
	defer cancel()
313

314
	setup(ctx, c.Bool("debug"))
315
	userMsg := private.PauseLogging(ctx)
316
	_, _ = fmt.Fprintln(os.Stdout, userMsg)
317
	return nil
318
}
319

320
func runResumeLogging(c *cli.Context) error {
321
	ctx, cancel := installSignals()
322
	defer cancel()
323

324
	setup(ctx, c.Bool("debug"))
325
	userMsg := private.ResumeLogging(ctx)
326
	_, _ = fmt.Fprintln(os.Stdout, userMsg)
327
	return nil
328
}
329

330
func runReleaseReopenLogging(c *cli.Context) error {
331
	ctx, cancel := installSignals()
332
	defer cancel()
333

334
	setup(ctx, c.Bool("debug"))
335
	userMsg := private.ReleaseReopenLogging(ctx)
336
	_, _ = fmt.Fprintln(os.Stdout, userMsg)
337
	return nil
338
}
339

340
func runSetLogSQL(c *cli.Context) error {
341
	ctx, cancel := installSignals()
342
	defer cancel()
343
	setup(ctx, c.Bool("debug"))
344

345
	extra := private.SetLogSQL(ctx, !c.Bool("off"))
346
	return handleCliResponseExtra(extra)
347
}
348