hrfee/jfa-go
1
0
Fork 0
mirror of https://github.com/hrfee/jfa-go.git synced 2024-12-22 00:50:12 +00:00
Code Issues Projects Releases Wiki Activity

logging: start consolidating log lines

Browse Source 
log messages are very fragmented and are often repeated many times throughout the software with small differences.

Messages will be listed in logmessages/, which are simply strings with
formatting directives if necessary. So far, only main.go has been
completed.
This commit is contained in:
Harvey Tindall 2024-07-31 17:45:05 +01:00
parent fb5d3c4165
commit e9b8d970d1
Signed by: hrfee
GPG Key ID: BBC65952848FB1A2
4 changed files with 127 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
go.mod
View File

@ -1,6 +1,6 @@
module github.com/hrfee/jfa-go
go 1.20
go 1.22.4
replace github.com/hrfee/jfa-go/docs => ./docs
@ -10,6 +10,8 @@ replace github.com/hrfee/jfa-go/ombi => ./ombi
replace github.com/hrfee/jfa-go/logger => ./logger
replace github.com/hrfee/jfa-go/logmessages => ./logmessages
replace github.com/hrfee/jfa-go/linecache => ./linecache
replace github.com/hrfee/jfa-go/api => ./api
@ -35,7 +37,7 @@ require (
github.com/hrfee/jfa-go/docs v0.0.0-20230626224816-f72960635dc3
github.com/hrfee/jfa-go/easyproxy v0.0.0-00010101000000-000000000000
github.com/hrfee/jfa-go/linecache v0.0.0-20230626224816-f72960635dc3
github.com/hrfee/jfa-go/logger v0.0.0-20230626224816-f72960635dc3
github.com/hrfee/jfa-go/logger v0.0.0-20240731152135-2d066ea7cd32
github.com/hrfee/jfa-go/ombi v0.0.0-20230626224816-f72960635dc3
github.com/hrfee/mediabrowser v0.3.13
github.com/itchyny/timefmt-go v0.1.5
@ -91,6 +93,7 @@ require (
github.com/gorilla/mux v1.8.0 // indirect
github.com/gorilla/websocket v1.5.0 // indirect
github.com/hrfee/jfa-go/jellyseerr v0.0.0-00010101000000-000000000000 // indirect
github.com/hrfee/jfa-go/logmessages v0.0.0-00010101000000-000000000000 // indirect
github.com/josharian/intern v1.0.0 // indirect
github.com/json-iterator/go v1.1.12 // indirect
github.com/klauspost/compress v1.16.6 // indirect

3
logmessages/go.mod Normal file
View File

@ -0,0 +1,3 @@
module github.com/hrfee/logmessages
go 1.22.4

62
logmessages/logmessages.go Normal file
View File

@ -0,0 +1,62 @@
package logmessages
const (
FailedLogging = "Failed to start log wrapper: %v\n"
NoConfig = "Couldn't find default config file"
FailedWriting = "Failed to write to \"%s\": %v"
FailedReading = "Failed to read from \"%s\": %v"
FailedOpen = "Failed to open \"%s\": %v"
CopyConfig = "Copied default configuration to \"%s\""
FailedCopyConfig = "Failed to copy default configuration to \"%s\": %v"
LoadConfig = "Loaded config file \"%s\""
FailedLoadConfig = "Failed to load config file \"%s\": %v"
SocketPath = "Socket Path: \"%s\""
FailedSocketConnect = "Couldn't establish socket connection at \"%s\": %v"
SocketCheckRunning = "Make sure jfa-go is running."
FailedSocketRead = "Couldn't read message on socket \"%s\": %v"
SocketWrite = "Command sent."
FailedSocketWrite = "Coudln't write message on socket \"%s\": %v"
FailedLangLoad = "Failed to load language files: %v"
UsingTLS = "Using TLS/HTTP2"
UsingOmbi = "Starting Ombi client"
UsingJellyseerr = "Starting Jellyseerr client"
UsingEmby = "Using Emby server type (EXPERIMENTAL: PWRs are not available, and support is limited.)"
UsingJellyfin = "Using Jellyfin server type"
UsingJellyfinAuth = "Using Jellyfin for authentication"
UsingLocalAuth = "Using local username/pw authentication (NOT RECOMMENDED)"
AuthJellyfin = "Authenticated with Jellyfin @ \"%s\""
FailedAuthJellyfin = "Failed to authenticate with Jellyfin @ \"%s\" (code %d): %v"
InitDiscord = "Initialized Discord daemon"
FailedInitDiscord = "Failed to initialize Discord daemon: %v"
InitTelegram = "Initialized Telegram daemon"
FailedInitTelegram = "Failed to initialize Telegram daemon: %v"
InitMatrix = "Initialized Matrix daemon"
FailedInitMatrix = "Failed to initialize Matrix daemon: %v"
InitRouter = "Initializing router"
LoadRoutes = "Loading Routes"
LoadingSetup = "Loading setup @ \"%s\""
ServingSetup = "Loaded, visit \"%s\" to start."
InvalidSSLCert = "Failed loading SSL Certificate \"%s\": %v"
InvalidSSLKey = "Failed loading SSL Keyfile \"%s\": %v"
FailServeSSL = "Failure serving with SSL/TLS: %v"
FailServe = "Failure serving: %v"
Serving = "Loaded @ \"%s\""
QuitReceived = "Restart/Quit signal received, please be patient."
Quitting = "Shutting down..."
Quit = "Server shut down."
FailedQuit = "Server shutdown failed: %v"
)

108
main.go
View File

@ -27,6 +27,7 @@ import (
"github.com/hrfee/jfa-go/easyproxy"
"github.com/hrfee/jfa-go/jellyseerr"
"github.com/hrfee/jfa-go/logger"
lm "github.com/hrfee/jfa-go/logmessages"
"github.com/hrfee/jfa-go/ombi"
"github.com/hrfee/mediabrowser"
"github.com/lithammer/shortuuid/v3"
@ -213,22 +214,21 @@ func start(asDaemon, firstCall bool) {
firstRun = true
dConfig, err := fs.ReadFile(localFS, "config-default.ini")
if err != nil {
app.err.Fatalf("Couldn't find default config file")
app.err.Fatalf(lm.NoConfig)
}
nConfig, err := os.Create(app.configPath)
if err != nil && os.IsNotExist(err) {
err = os.MkdirAll(filepath.Dir(app.configPath), 0760)
}
if err != nil {
app.err.Printf("Couldn't open config file for writing: \"%s\"", app.configPath)
app.err.Fatalf("Error: %s", err)
app.err.Fatalf(lm.FailedWriting, app.configPath, err)
}
defer nConfig.Close()
_, err = nConfig.Write(dConfig)
if err != nil {
app.err.Fatalf("Couldn't copy default config.")
app.err.Fatalf(lm.FailedCopyConfig, app.configPath, err)
}
app.info.Printf("Copied default configuration to \"%s\"", app.configPath)
app.info.Printf(lm.CopyConfig, app.configPath)
tempConfig, _ := ini.Load(app.configPath)
tempConfig.Section("").Key("first_run").SetValue("true")
tempConfig.SaveTo(app.configPath)
@ -237,8 +237,9 @@ func start(asDaemon, firstCall bool) {
var debugMode bool
var address string
if err := app.loadConfig(); err != nil {
app.err.Fatalf("Failed to load config file \"%s\": %v", app.configPath, err)
app.err.Fatalf(lm.FailedLoadConfig, app.configPath, err)
}
app.info.Printf(lm.LoadConfig, app.configPath)
if app.config.Section("").Key("first_run").MustBool(false) {
firstRun = true
@ -270,7 +271,7 @@ func start(asDaemon, firstCall bool) {
os.Remove(SOCK)
listener, err := net.Listen("unix", SOCK)
if err != nil {
app.err.Fatalf("Couldn't establish socket connection at %s\n", SOCK)
app.err.Fatalf(lm.FailedSocketConnect, SOCK, err)
}
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt, syscall.SIGTERM)
@ -286,13 +287,13 @@ func start(asDaemon, firstCall bool) {
for {
con, err := listener.Accept()
if err != nil {
app.err.Printf("Couldn't read message on %s: %s", SOCK, err)
app.err.Printf(lm.FailedSocketRead, SOCK, err)
continue
}
buf := make([]byte, 512)
nr, err := con.Read(buf)
if err != nil {
app.err.Printf("Couldn't read message on %s: %s", SOCK, err)
app.err.Printf(lm.FailedSocketRead, SOCK, err)
continue
}
command := string(buf[0:nr])
@ -317,13 +318,13 @@ func start(asDaemon, firstCall bool) {
err = app.storage.loadLang(langFS, os.DirFS(externalLang))
}
if err != nil {
app.info.Fatalf("Failed to load language files: %+v\n", err)
app.info.Fatalf(lm.FailedLangLoad, err)
}
if !firstRun {
app.host = app.config.Section("ui").Key("host").String()
if app.config.Section("advanced").Key("tls").MustBool(false) {
app.info.Println("Using TLS/HTTP2")
app.info.Println(lm.UsingTLS)
app.port = app.config.Section("advanced").Key("tls_port").MustInt(8057)
} else {
app.port = app.config.Section("ui").Key("port").MustInt(8056)
@ -348,10 +349,8 @@ func start(asDaemon, firstCall bool) {
}
address = fmt.Sprintf("%s:%d", app.host, app.port)
app.debug.Printf("Loaded config file \"%s\"", app.configPath)
if app.config.Section("ombi").Key("enabled").MustBool(false) {
app.debug.Printf("Connecting to Ombi")
app.debug.Printf(lm.UsingOmbi)
ombiServer := app.config.Section("ombi").Key("server").String()
app.ombi = ombi.NewOmbi(
ombiServer,
@ -362,7 +361,7 @@ func start(asDaemon, firstCall bool) {
}
if app.config.Section("jellyseerr").Key("enabled").MustBool(false) {
app.debug.Printf("Connecting to Jellyseerr")
app.debug.Printf(lm.UsingJellyseerr)
jellyseerrServer := app.config.Section("jellyseerr").Key("server").String()
app.js = jellyseerr.NewJellyseerr(
jellyseerrServer,
@ -398,10 +397,9 @@ func start(asDaemon, firstCall bool) {
if stringServerType == "emby" {
serverType = mediabrowser.EmbyServer
timeoutHandler = mediabrowser.NewNamedTimeoutHandler("Emby", "\""+server+"\"", true)
app.info.Println("Using Emby server type")
fmt.Println(warning("WARNING: Emby compatibility is experimental, and support is limited.\nPassword resets are not available."))
app.info.Println(lm.UsingEmby)
} else {
app.info.Println("Using Jellyfin server type")
app.info.Println(lm.UsingJellyfin)
}
app.jf, err = mediabrowser.NewServer(
@ -415,7 +413,7 @@ func start(asDaemon, firstCall bool) {
cacheTimeout,
)
if err != nil {
app.err.Fatalf("Failed to authenticate with Jellyfin @ \"%s\": %v", server, err)
app.err.Fatalf(lm.FailedAuthJellyfin, server, -1, err)
}
if debugMode {
app.jf.Verbose = true
@ -433,9 +431,9 @@ func start(asDaemon, firstCall bool) {
}
_, status, err = app.jf.MustAuthenticate(app.config.Section("jellyfin").Key("username").String(), app.config.Section("jellyfin").Key("password").String(), retryOpts)
if status != 200 || err != nil {
app.err.Fatalf("Failed to authenticate with Jellyfin @ \"%s\" (%d): %v", server, status, err)
app.err.Fatalf(lm.FailedAuthJellyfin, server, status, err)
}
app.info.Printf("Authenticated with \"%s\"", server)
app.info.Printf(lm.AuthJellyfin, server)
runMigrations(app)
@ -448,8 +446,9 @@ func start(asDaemon, firstCall bool) {
user.Username = app.config.Section("ui").Key("username").String()
user.Password = app.config.Section("ui").Key("password").String()
app.adminUsers = append(app.adminUsers, user)
app.info.Println(lm.UsingLocalAuth)
} else {
app.debug.Println("Using Jellyfin for authentication")
app.debug.Println(lm.UsingJellyfinAuth)
app.authJf, _ = mediabrowser.NewServer(serverType, server, "jfa-go", app.version, "auth", "auth", timeoutHandler, cacheTimeout)
if debugMode {
app.authJf.Verbose = true
@ -515,9 +514,10 @@ func start(asDaemon, firstCall bool) {
if telegramEnabled {
app.telegram, err = newTelegramDaemon(app)
if err != nil {
app.err.Printf("Failed to authenticate with Telegram: %v", err)
app.err.Printf(lm.FailedInitTelegram, err)
telegramEnabled = false
} else {
app.debug.Println(lm.InitTelegram)
go app.telegram.run()
defer app.telegram.Shutdown()
}
@ -525,9 +525,10 @@ func start(asDaemon, firstCall bool) {
if discordEnabled {
app.discord, err = newDiscordDaemon(app)
if err != nil {
app.err.Printf("Failed to authenticate with Discord: %v", err)
app.err.Printf(lm.FailedInitDiscord, err)
discordEnabled = false
} else {
app.debug.Println(lm.InitDiscord)
go app.discord.run()
defer app.discord.Shutdown()
}
@ -535,9 +536,10 @@ func start(asDaemon, firstCall bool) {
if matrixEnabled {
app.matrix, err = newMatrixDaemon(app)
if err != nil {
app.err.Printf("Failed to initialize Matrix daemon: %v", err)
app.err.Printf(lm.FailedInitMatrix, err)
matrixEnabled = false
} else {
app.debug.Println(lm.InitMatrix)
go app.matrix.run()
defer app.matrix.Shutdown()
}
@ -558,7 +560,7 @@ func start(asDaemon, firstCall bool) {
app.storage.lang.SetupPath = "setup"
err := app.storage.loadLangSetup(langFS)
if err != nil {
app.info.Fatalf("Failed to load language files: %+v\n", err)
app.info.Fatalf(lm.FailedLangLoad, err)
}
}
@ -566,14 +568,14 @@ func start(asDaemon, firstCall bool) {
// workaround for potentially broken windows mime types
mime.AddExtensionType(".js", "application/javascript")
app.info.Println("Initializing router")
app.info.Println(lm.InitRouter)
router := app.loadRouter(address, debugMode)
app.info.Println("Loading routes")
app.info.Println(lm.LoadRoutes)
if !firstRun {
app.loadRoutes(router)
} else {
app.loadSetup(router)
app.info.Printf("Loading setup @ %s", address)
app.info.Printf(lm.LoadingSetup, address)
}
go func() {
if app.config.Section("advanced").Key("tls").MustBool(false) {
@ -581,45 +583,45 @@ func start(asDaemon, firstCall bool) {
key := app.config.Section("advanced").Key("tls_key").MustString("")
if err := SRV.ListenAndServeTLS(cert, key); err != nil {
filesToCheck := []string{cert, key}
fileNames := []string{"Certificate", "Key"}
fileNames := []string{lm.InvalidSSLCert, lm.InvalidSSLKey}
for i, v := range filesToCheck {
_, err := os.Stat(v)
if err != nil {
app.err.Printf("SSL/TLS %s: %v\n", fileNames[i], err)
app.err.Printf(fileNames[i], v, err)
}
}
if err == http.ErrServerClosed {
app.err.Printf("Failure serving with SSL/TLS: %s", err)
app.err.Printf(lm.FailServeSSL, err)
} else {
app.err.Fatalf("Failure serving with SSL/TLS: %s", err)
app.err.Fatalf(lm.FailServeSSL, err)
}
}
} else {
if err := SRV.ListenAndServe(); err != nil {
if err == http.ErrServerClosed {
app.err.Printf("Failure serving: %s", err)
app.err.Printf(lm.FailServe, err)
} else {
app.err.Fatalf("Failure serving: %s", err)
app.err.Fatalf(lm.FailServe, err)
}
}
}
}()
if firstRun {
app.info.Printf("Loaded, visit %s to start.", address)
app.info.Printf(lm.ServingSetup, address)
} else {
app.info.Printf("Loaded @ %s", address)
app.info.Printf(lm.Serving, address)
}
waitForRestart()
app.info.Printf("Restart/Quit signal received, give me a second!")
app.info.Printf(lm.QuitReceived)
ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
defer cancel()
if err := SRV.Shutdown(ctx); err != nil {
app.err.Fatalf("Server shutdown error: %s", err)
app.err.Fatalf(lm.FailedQuit, err)
}
app.info.Println("Server shut down.")
app.info.Println(lm.Quit)
return
}
@ -631,7 +633,7 @@ func shutdown() {
}
func (app *appContext) shutdown() {
app.info.Println("Shutting down...")
app.info.Println(lm.Quitting)
shutdown()
}
@ -715,15 +717,17 @@ func printVersion() {
fmt.Println(info("jfa-go version: %s (%s)%s\n", hiwhite(version), white(commit), tray))
}
const SYSTEMD_SERVICE = "jfa-go.service"
func main() {
f, err := logOutput()
if err != nil {
fmt.Printf("Failed to start logging: %v\n", err)
fmt.Printf(lm.FailedLogging, err)
}
defer f()
printVersion()
SOCK = filepath.Join(temp, SOCK)
fmt.Println("Socket:", SOCK)
fmt.Printf(lm.SocketPath+"\n", SOCK)
if flagPassed("test") {
TEST = true
}
@ -752,21 +756,23 @@ func main() {
} else if flagPassed("stop") {
con, err := net.Dial("unix", SOCK)
if err != nil {
fmt.Printf("Couldn't dial socket %s, are you sure jfa-go is running?\n", SOCK)
fmt.Printf(lm.FailedSocketConnect+"\n", SOCK, err)
fmt.Println(lm.SocketCheckRunning)
os.Exit(1)
}
_, err = con.Write([]byte("stop"))
if err != nil {
fmt.Printf("Couldn't send command to socket %s, are you sure jfa-go is running?\n", SOCK)
fmt.Printf(lm.FailedSocketWrite+"\n", SOCK, err)
fmt.Println(lm.SocketCheckRunning)
os.Exit(1)
}
fmt.Println("Sent.")
fmt.Println(lm.SocketWrite)
} else if flagPassed("daemon") {
start(true, true)
} else if flagPassed("systemd") {
service, err := fs.ReadFile(localFS, "jfa-go.service")
service, err := fs.ReadFile(localFS, SYSTEMD_SERVICE)
if err != nil {
fmt.Printf("Couldn't read jfa-go.service: %v\n", err)
fmt.Printf(lm.FailedReading+"\n", SYSTEMD_SERVICE, err)
os.Exit(1)
}
absPath, err := filepath.Abs(os.Args[0])
@ -780,13 +786,13 @@ func main() {
}
}
service = []byte(strings.Replace(string(service), "{executable}", command, 1))
err = os.WriteFile("jfa-go.service", service, 0666)
err = os.WriteFile(SYSTEMD_SERVICE, service, 0666)
if err != nil {
fmt.Printf("Couldn't write jfa-go.service: %v\n", err)
fmt.Printf(lm.FailedWriting+"\n", SYSTEMD_SERVICE, err)
os.Exit(1)
}
fmt.Println(info(`If you want to execute jfa-go with special arguments, re-run this command with them.
Move the newly created "jfa-go.service" file to ~/.config/systemd/user (Creating it if necessary).
Move the newly created SYSTEMD_SERVICE file to ~/.config/systemd/user (Creating it if necessary).
Then run "systemctl --user daemon-reload".
You can then run: