From 577e37456a7fe7705209966e0ef9417e331ee197 Mon Sep 17 00:00:00 2001 From: n0rdy Date: Mon, 7 Aug 2023 21:46:03 +0200 Subject: [PATCH] Fixed logs for permissions issues case --- cmd/adminStartServer.go | 4 +-- cmd/at.go | 18 +++++------ cmd/cancel.go | 8 ++--- cmd/change.go | 26 ++++++++-------- cmd/completion.go | 12 ++++---- cmd/docs.go | 12 ++++---- cmd/in.go | 18 +++++------ cmd/list.go | 10 +++---- cmd/logs.go | 8 ++--- cmd/root.go | 2 +- cmd/start.go | 6 ++-- cmd/stop.go | 4 +-- httpclient/httpclient.go | 56 +++++++++++++++++------------------ httpserver/api/router.go | 48 +++++++++++++++--------------- httpserver/httpserver.go | 12 ++++---- httpserver/service/service.go | 8 ++--- logger/logger.go | 42 ++++++++++++++++++++++++++ main.go | 5 ++-- utils/datetime.go | 10 +++---- utils/logger.go | 27 ----------------- 20 files changed, 176 insertions(+), 160 deletions(-) create mode 100644 logger/logger.go delete mode 100644 utils/logger.go diff --git a/cmd/adminStartServer.go b/cmd/adminStartServer.go index 36586b7..4442633 100644 --- a/cmd/adminStartServer.go +++ b/cmd/adminStartServer.go @@ -1,8 +1,8 @@ package cmd import ( - "log" "n0rdy.me/remindme/httpserver" + "n0rdy.me/remindme/logger" "github.com/spf13/cobra" ) @@ -15,7 +15,7 @@ var adminStartServerCmd = &cobra.Command{ Use "start" command instead if you need to start the remindme app.`, Run: func(cmd *cobra.Command, args []string) { - log.Println("adminStartServer command: called") + logger.Log("adminStartServer command: called") httpserver.Start() }, } diff --git a/cmd/at.go b/cmd/at.go index 45a8c3e..cb672ca 100644 --- a/cmd/at.go +++ b/cmd/at.go @@ -3,9 +3,9 @@ package cmd import ( "github.com/spf13/cobra" "github.com/spf13/pflag" - "log" "n0rdy.me/remindme/common" "n0rdy.me/remindme/httpclient" + "n0rdy.me/remindme/logger" "n0rdy.me/remindme/utils" "time" ) @@ -22,7 +22,7 @@ The command expects a reminder message to be provided via the "--about" flag - o List the upcoming reminders with the "list" command.`, RunE: func(cmd *cobra.Command, args []string) error { - log.Println("at command: called") + logger.Log("at command: called") reminder, err := parseAtCmd(cmd) if err != nil { @@ -48,11 +48,11 @@ func parseAtCmd(cmd *cobra.Command) (*common.Reminder, error) { message, err := flags.GetString(common.AboutFlag) if err != nil { - log.Println("at command: error while parsing flag: "+common.AboutFlag, err) + logger.Log("at command: error while parsing flag: "+common.AboutFlag, err) return nil, common.ErrWrongFormattedStringFlag(common.AboutFlag) } if message == "" { - log.Println("at command: mandatory flag not provided: " + common.AboutFlag) + logger.Log("at command: mandatory flag not provided: " + common.AboutFlag) return nil, common.ErrInAtCmdNoMessageProvided } @@ -72,27 +72,27 @@ func calcRemindAtForAtFlag(flags *pflag.FlagSet) (time.Time, error) { t, err := flags.GetString(common.TimeFlag) if err != nil { - log.Println("at command: error while parsing flag: "+common.TimeFlag, err) + logger.Log("at command: error while parsing flag: "+common.TimeFlag, err) return now, common.ErrWrongFormattedStringFlag(common.TimeFlag) } am, err := flags.GetString(common.AmFlag) if err != nil { - log.Println("at command: error while parsing flag: "+common.AmFlag, err) + logger.Log("at command: error while parsing flag: "+common.AmFlag, err) return now, common.ErrWrongFormattedStringFlag(common.AmFlag) } pm, err := flags.GetString(common.PmFlag) if err != nil { - log.Println("at command: error while parsing flag: "+common.PmFlag, err) + logger.Log("at command: error while parsing flag: "+common.PmFlag, err) return now, common.ErrWrongFormattedStringFlag(common.PmFlag) } if t == "" && am == "" && pm == "" { - log.Println("at command: no time flags provided") + logger.Log("at command: no time flags provided") return now, common.ErrAtCmdTimeNotProvided } // more than 1 time-related flag is provided if (t != "" && am != "") || (t != "" && pm != "") || (am != "" && pm != "") { - log.Println("at command: more than 1 time flag provided") + logger.Log("at command: more than 1 time flag provided") return now, common.ErrAtCmdInvalidTimeflagsProvided } diff --git a/cmd/cancel.go b/cmd/cancel.go index a185b45..db22fcd 100644 --- a/cmd/cancel.go +++ b/cmd/cancel.go @@ -2,9 +2,9 @@ package cmd import ( "github.com/spf13/cobra" - "log" "n0rdy.me/remindme/common" "n0rdy.me/remindme/httpclient" + "n0rdy.me/remindme/logger" ) type CancelFlags struct { @@ -22,7 +22,7 @@ The command expects a reminder ID to be provided via the "--id" flag - otherwise List the upcoming reminders with the "list" command.`, RunE: func(cmd *cobra.Command, args []string) error { - log.Println("cancel command: called") + logger.Log("cancel command: called") cancelFlags, err := parseCancelCmd(cmd) if err != nil { @@ -49,13 +49,13 @@ func parseCancelCmd(cmd *cobra.Command) (*CancelFlags, error) { isAll := flags.Lookup(common.AllFlag).Changed id, err := flags.GetInt(common.IdFlag) if err != nil { - log.Println("cancel command: error while parsing flag: "+common.IdFlag, err) + logger.Log("cancel command: error while parsing flag: "+common.IdFlag, err) return nil, common.ErrWrongFormattedIntFlag(common.IdFlag) } // catches "no flags provided" and "all flags provided" cases if (id == 0 && !isAll) || (id != 0 && isAll) { - log.Println("cancel command: invalid flags provided") + logger.Log("cancel command: invalid flags provided") return nil, common.ErrCancelCmdInvalidFlagsProvided } diff --git a/cmd/change.go b/cmd/change.go index da0dc99..18d0975 100644 --- a/cmd/change.go +++ b/cmd/change.go @@ -2,9 +2,9 @@ package cmd import ( "github.com/spf13/cobra" - "log" "n0rdy.me/remindme/common" "n0rdy.me/remindme/httpclient" + "n0rdy.me/remindme/logger" "n0rdy.me/remindme/utils" "time" ) @@ -35,7 +35,7 @@ Negative integer values are not accepted - the error will be produced in such ca List the upcoming reminders with the "list" command.`, RunE: func(cmd *cobra.Command, args []string) error { - log.Println("change command: called") + logger.Log("change command: called") changeFlags, err := parseChangeCmd(cmd) if err != nil { @@ -75,23 +75,23 @@ func parseChangeCmd(cmd *cobra.Command) (*ChangeFlags, error) { id, err := flags.GetInt(common.IdFlag) if err != nil { - log.Println("change command: error while parsing flag: "+common.IdFlag, err) + logger.Log("change command: error while parsing flag: "+common.IdFlag, err) return nil, common.ErrWrongFormattedIntFlag(common.IdFlag) } if id == 0 { - log.Println("change command: mandatory flag not provided: " + common.IdFlag) + logger.Log("change command: mandatory flag not provided: " + common.IdFlag) return nil, common.ErrChangeCmdIdNotProvided } message, err := flags.GetString(common.AboutFlag) if err != nil { - log.Println("change command: error while parsing flag: "+common.AboutFlag, err) + logger.Log("change command: error while parsing flag: "+common.AboutFlag, err) return nil, common.ErrWrongFormattedStringFlag(common.AboutFlag) } t, err := flags.GetString(common.TimeFlag) if err != nil { - log.Println("change command: error while parsing flag: "+common.TimeFlag, err) + logger.Log("change command: error while parsing flag: "+common.TimeFlag, err) return nil, common.ErrWrongFormattedStringFlag(common.TimeFlag) } @@ -99,37 +99,37 @@ func parseChangeCmd(cmd *cobra.Command) (*ChangeFlags, error) { // no changes provided if message == "" && t == "" && !isPostpone { - log.Println("change command: no changes provided") + logger.Log("change command: no changes provided") return nil, common.ErrChangeCmdInvalidFlagsProvided } // both "new time" and "postpone" provided if t != "" && isPostpone { - log.Println("change command: both new time and postpone provided") + logger.Log("change command: both new time and postpone provided") return nil, common.ErrChangeCmdInvalidTimeFlagsProvided } seconds, err := flags.GetInt(common.SecondsFlag) if err != nil { - log.Println("change command: error while parsing flag: "+common.SecondsFlag, err) + logger.Log("change command: error while parsing flag: "+common.SecondsFlag, err) return nil, common.ErrWrongFormattedIntFlag(common.SecondsFlag) } minutes, err := flags.GetInt(common.MinutesFlag) if err != nil { - log.Println("change command: error while parsing flag: "+common.MinutesFlag, err) + logger.Log("change command: error while parsing flag: "+common.MinutesFlag, err) return nil, common.ErrWrongFormattedIntFlag(common.MinutesFlag) } hours, err := flags.GetInt(common.HoursFlag) if err != nil { - log.Println("change command: error while parsing flag: "+common.SecondsFlag, err) + logger.Log("change command: error while parsing flag: "+common.SecondsFlag, err) return nil, common.ErrWrongFormattedIntFlag(common.HoursFlag) } if seconds < 0 || minutes < 0 || hours < 0 { - log.Println("change command: negative values provided for time shift flags") + logger.Log("change command: negative values provided for time shift flags") return nil, common.ErrChangeCmdInvalidPostponeDuration } if isPostpone && seconds == 0 && minutes == 0 && hours == 0 { - log.Println("change command: no values provided for time shift flags") + logger.Log("change command: no values provided for time shift flags") return nil, common.ErrChangeCmdPostponeDurationNotProvided } diff --git a/cmd/completion.go b/cmd/completion.go index 67c2adf..3f8f2a5 100644 --- a/cmd/completion.go +++ b/cmd/completion.go @@ -2,8 +2,8 @@ package cmd import ( "github.com/spf13/cobra" - "log" "n0rdy.me/remindme/common" + "n0rdy.me/remindme/logger" "n0rdy.me/remindme/utils" "os" ) @@ -21,7 +21,7 @@ source <(remindme completion) Please, check the PowerShell documentation (https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/register-argumentcompleter?view=powershell-7.3) for more information about loading completions for this shell type.`, RunE: func(cmd *cobra.Command, args []string) error { - log.Println("completion command: called") + logger.Log("completion command: called") return setCompletionIfPossible() }, } @@ -43,19 +43,19 @@ func setCompletionIfPossible() error { case common.FishShell: return rootCmd.GenZshCompletion(os.Stdout) case "": - log.Println("completion command: unknown shell type error") + logger.Log("completion command: unknown shell type error") return common.ErrCompletionCmdUnknownShell default: - log.Println("completion command: unsupported shell type error: " + shellType) + logger.Log("completion command: unsupported shell type error: " + shellType) return common.ErrCompletionCmdUnsupportedShell(shellType) } case common.WindowsOS: return rootCmd.GenPowerShellCompletion(os.Stdout) case "": - log.Println("completion command: unknown OS type error") + logger.Log("completion command: unknown OS type error") return common.ErrCompletionCmdUnknownOS default: - log.Println("completion command: unsupported OS type error: " + osType) + logger.Log("completion command: unsupported OS type error: " + osType) return common.ErrCompletionCmdUnsupportedOs(osType) } } diff --git a/cmd/docs.go b/cmd/docs.go index 4d03210..e60c898 100644 --- a/cmd/docs.go +++ b/cmd/docs.go @@ -5,8 +5,8 @@ import ( "github.com/spf13/cobra" "github.com/spf13/cobra/doc" "io" - "log" "n0rdy.me/remindme/common" + "n0rdy.me/remindme/logger" "os" ) @@ -16,7 +16,7 @@ var docsCmd = &cobra.Command{ Short: "Generate documentation for remindme command", Long: "Generate documentation for remindme command.", RunE: func(cmd *cobra.Command, args []string) error { - log.Println("docs command: called") + logger.Log("docs command: called") dir, err := getDir(cmd) if err != nil { @@ -35,13 +35,13 @@ func init() { func getDir(cmd *cobra.Command) (string, error) { dir, err := cmd.Flags().GetString(common.DirFlag) if err != nil { - log.Println("docs command: error while parsing flag: "+common.DirFlag, err) + logger.Log("docs command: error while parsing flag: "+common.DirFlag, err) return "", common.ErrWrongFormattedStringFlag(common.DirFlag) } if dir == "" { if dir, err = os.MkdirTemp("", "remindme"); err != nil { - log.Println("docs command: error while creating temp dir", err) + logger.Log("docs command: error while creating temp dir", err) return "", common.ErrDocsCmdOnDirCreation } } @@ -50,12 +50,12 @@ func getDir(cmd *cobra.Command) (string, error) { func generateDocs(out io.Writer, dir string) error { if err := doc.GenMarkdownTree(rootCmd, dir); err != nil { - log.Println("docs command: error while generating docs", err) + logger.Log("docs command: error while generating docs", err) return common.ErrDocsCmdOnDocsGeneration } _, err := fmt.Fprintf(out, "Documentation successfully created in %s\n", dir) if err != nil { - log.Println("docs command: error while writing to output", err) + logger.Log("docs command: error while writing to output", err) } return nil } diff --git a/cmd/in.go b/cmd/in.go index 4976d24..a2b700d 100644 --- a/cmd/in.go +++ b/cmd/in.go @@ -2,9 +2,9 @@ package cmd import ( "github.com/spf13/pflag" - "log" "n0rdy.me/remindme/common" "n0rdy.me/remindme/httpclient" + "n0rdy.me/remindme/logger" "n0rdy.me/remindme/utils" "time" @@ -24,7 +24,7 @@ The command expects a reminder message to be provided via the "--about" flag - o List the upcoming reminders with the "list" command.`, RunE: func(cmd *cobra.Command, args []string) error { - log.Println("in command: called") + logger.Log("in command: called") reminder, err := parseInCmd(cmd) if err != nil { @@ -50,11 +50,11 @@ func parseInCmd(cmd *cobra.Command) (*common.Reminder, error) { message, err := flags.GetString(common.AboutFlag) if err != nil { - log.Println("in command: error while parsing flag: "+common.AboutFlag, err) + logger.Log("in command: error while parsing flag: "+common.AboutFlag, err) return nil, common.ErrWrongFormattedStringFlag(common.AboutFlag) } if message == "" { - log.Println("in command: mandatory flag not provided: " + common.AboutFlag) + logger.Log("in command: mandatory flag not provided: " + common.AboutFlag) return nil, common.ErrInAtCmdNoMessageProvided } @@ -74,26 +74,26 @@ func calcRemindAtForInFlag(flags *pflag.FlagSet) (time.Time, error) { seconds, err := flags.GetInt(common.SecondsFlag) if err != nil { - log.Println("in command: error while parsing flag: "+common.SecondsFlag, err) + logger.Log("in command: error while parsing flag: "+common.SecondsFlag, err) return now, common.ErrWrongFormattedIntFlag(common.SecondsFlag) } minutes, err := flags.GetInt(common.MinutesFlag) if err != nil { - log.Println("in command: error while parsing flag: "+common.MinutesFlag, err) + logger.Log("in command: error while parsing flag: "+common.MinutesFlag, err) return now, common.ErrWrongFormattedIntFlag(common.MinutesFlag) } hours, err := flags.GetInt(common.HoursFlag) if err != nil { - log.Println("in command: error while parsing flag: "+common.HoursFlag, err) + logger.Log("in command: error while parsing flag: "+common.HoursFlag, err) return now, common.ErrWrongFormattedIntFlag(common.HoursFlag) } if seconds == 0 && minutes == 0 && hours == 0 { - log.Println("in command: no duration flags provided") + logger.Log("in command: no duration flags provided") return now, common.ErrInCmdDurationNotProvided } if seconds < 0 || minutes < 0 || hours < 0 { - log.Println("in command: negative duration flags provided") + logger.Log("in command: negative duration flags provided") return now, common.ErrInCmdInvalidDuration } diff --git a/cmd/list.go b/cmd/list.go index 41352af..b8427f9 100644 --- a/cmd/list.go +++ b/cmd/list.go @@ -3,9 +3,9 @@ package cmd import ( "fmt" "github.com/spf13/cobra" - "log" "n0rdy.me/remindme/common" "n0rdy.me/remindme/httpclient" + "n0rdy.me/remindme/logger" "os" "sort" "text/tabwriter" @@ -31,7 +31,7 @@ This should be resolved in a matter of seconds. Cancel reminder with the "cancel --id ${REMINDER_ID}" command`, RunE: func(cmd *cobra.Command, args []string) error { - log.Println("list command: called") + logger.Log("list command: called") sortingFlags, err := resolveSorting(cmd) if err != nil { @@ -75,7 +75,7 @@ func resolveSorting(cmd *cobra.Command) (*SortingFlags, error) { // sorting not requested (via --sort flag), but other sorting flags provided if !shouldSort && (byId || byMessage || byTime || asc || desc) { - log.Println("list command: sorting not requested, but other sorting flags provided") + logger.Log("list command: sorting not requested, but other sorting flags provided") return nil, common.ErrListCmdSortingNotRequested } // sorting not requested at all @@ -84,12 +84,12 @@ func resolveSorting(cmd *cobra.Command) (*SortingFlags, error) { } // sorting by only 1 param is supported if (byId && byMessage) || (byId && byTime) || (byMessage && byTime) { - log.Println("list command: provided more than 1 sorting flag") + logger.Log("list command: provided more than 1 sorting flag") return nil, common.ErrListCmdSortingInvalidSortByFlagsProvided } // either ASC or DESC sorting order should be requested, not both if asc && desc { - log.Println("list command: provided both ASC and DESC sorting flags") + logger.Log("list command: provided both ASC and DESC sorting flags") return nil, common.ErrListCmdSortingInvalidSortingOrderFlagsProvided } diff --git a/cmd/logs.go b/cmd/logs.go index 1261b69..d941d61 100644 --- a/cmd/logs.go +++ b/cmd/logs.go @@ -5,8 +5,8 @@ import ( "fmt" "github.com/spf13/cobra" "io" - "log" "n0rdy.me/remindme/common" + "n0rdy.me/remindme/logger" "n0rdy.me/remindme/utils" "os" ) @@ -56,7 +56,7 @@ func parseLogsCmd(cmd *cobra.Command) (*LogsFlags, error) { isServer := cmd.Flags().Lookup(common.ServerFlag).Changed if isClient && isServer { - log.Println("logs command: both flags provided, only one is expected") + logger.Log("logs command: both flags provided, only one is expected") return nil, common.ErrLogsCmdBothFlagsProvided } if !isClient && !isServer { @@ -73,7 +73,7 @@ func printLogs(logsFileName string) error { logsFile, err := os.Open(logsDir + logsFileName) if err != nil { - log.Println("logs command: failed to open logs file", err) + logger.Log("logs command: failed to open logs file", err) return common.ErrLogsCmdCannotOpenLogsFile } defer logsFile.Close() @@ -87,7 +87,7 @@ func printLogs(logsFileName string) error { if err == io.EOF { break } - log.Println("logs command: failed to read logs file", err) + logger.Log("logs command: failed to read logs file", err) return err } diff --git a/cmd/root.go b/cmd/root.go index c088d1f..f8a273f 100644 --- a/cmd/root.go +++ b/cmd/root.go @@ -11,7 +11,7 @@ var rootCmd = &cobra.Command{ Use: "remindme", Short: "A tool to set reminders from the terminal", Long: `A tool to set reminders from the terminal.`, - Version: "1.0.1", + Version: "1.0.2", } // Execute adds all child commands to the root command and sets flags appropriately. diff --git a/cmd/start.go b/cmd/start.go index 6cb513f..a327f02 100644 --- a/cmd/start.go +++ b/cmd/start.go @@ -2,9 +2,9 @@ package cmd import ( "github.com/spf13/cobra" - "log" "n0rdy.me/remindme/common" "n0rdy.me/remindme/httpclient" + "n0rdy.me/remindme/logger" "os" "os/exec" ) @@ -21,7 +21,7 @@ for sending the notifications once the requested time comes. Stop the remindme app with the "stop" command.`, RunE: func(cmd *cobra.Command, args []string) error { - log.Println("start command: called") + logger.Log("start command: called") if httpclient.Healthcheck() { return common.ErrStartCmdAlreadyRunning @@ -31,7 +31,7 @@ Stop the remindme app with the "stop" command.`, command.Stderr = os.Stderr if err := command.Start(); err != nil { - log.Println("start command: error while starting HTTP server", err) + logger.Log("start command: error while starting HTTP server", err) return err } return nil diff --git a/cmd/stop.go b/cmd/stop.go index 929f1ce..38bf1ef 100644 --- a/cmd/stop.go +++ b/cmd/stop.go @@ -2,8 +2,8 @@ package cmd import ( "github.com/spf13/cobra" - "log" "n0rdy.me/remindme/httpclient" + "n0rdy.me/remindme/logger" ) // stopCmd represents the stop command @@ -18,7 +18,7 @@ and the notifications won't be sent. Start the remindme app with the "start" command.`, RunE: func(cmd *cobra.Command, args []string) error { - log.Println("stop command: called") + logger.Log("stop command: called") return httpclient.StopServer() }, } diff --git a/httpclient/httpclient.go b/httpclient/httpclient.go index c6d23bb..f24433a 100644 --- a/httpclient/httpclient.go +++ b/httpclient/httpclient.go @@ -4,8 +4,8 @@ import ( "bytes" "encoding/json" "io" - "log" "n0rdy.me/remindme/common" + "n0rdy.me/remindme/logger" "net/http" "strconv" ) @@ -17,17 +17,17 @@ var httpClient = http.Client{} func CreateReminder(reminder common.Reminder) error { reqBody, err := json.Marshal(reminder) if err != nil { - log.Println("CreateReminder request: unexpected error happened on encoding request body", err) + logger.Log("CreateReminder request: unexpected error happened on encoding request body", err) return common.ErrHttpInternal } resp, err := httpClient.Post(serverUrl+"/api/v1/reminders", "application/json", bytes.NewReader(reqBody)) if err != nil { - log.Println("CreateReminder request: unexpected error happened on POST HTTP call", err) + logger.Log("CreateReminder request: unexpected error happened on POST HTTP call", err) return common.ErrHttpOnCallingServer } if resp.StatusCode != http.StatusOK { - log.Println("CreateReminder request: unexpected status code received: " + strconv.Itoa(resp.StatusCode)) + logger.Log("CreateReminder request: unexpected status code received: " + strconv.Itoa(resp.StatusCode)) return common.ErrHttpOnSettingUpReminder } return nil @@ -36,26 +36,26 @@ func CreateReminder(reminder common.Reminder) error { func GetAllReminders() ([]common.Reminder, error) { resp, err := httpClient.Get(serverUrl + "/api/v1/reminders") if err != nil { - log.Println("GetAllReminders request: unexpected error happened on GET HTTP call", err) + logger.Log("GetAllReminders request: unexpected error happened on GET HTTP call", err) return nil, common.ErrHttpOnCallingServer } defer resp.Body.Close() if resp.StatusCode != http.StatusOK { - log.Println("GetAllReminders request: unexpected status code received: " + strconv.Itoa(resp.StatusCode)) + logger.Log("GetAllReminders request: unexpected status code received: " + strconv.Itoa(resp.StatusCode)) return nil, common.ErrHttpOnGettingAllReminders } respBody, err := io.ReadAll(resp.Body) if err != nil { - log.Println("GetAllReminders request: unexpected error happened on response body reading", err) + logger.Log("GetAllReminders request: unexpected error happened on response body reading", err) return nil, common.ErrHttpInternal } reminders := make([]common.Reminder, 0) err = json.Unmarshal(respBody, &reminders) if err != nil { - log.Println("GetAllReminders request: unexpected error happened on response body decoding", err) + logger.Log("GetAllReminders request: unexpected error happened on response body decoding", err) return nil, common.ErrHttpInternal } return reminders, err @@ -64,17 +64,17 @@ func GetAllReminders() ([]common.Reminder, error) { func DeleteAllReminders() error { req, err := http.NewRequest(http.MethodDelete, serverUrl+"/api/v1/reminders", nil) if err != nil { - log.Println("DeleteAllReminders request: unexpected error happened on preparing DELETE HTTP request", err) + logger.Log("DeleteAllReminders request: unexpected error happened on preparing DELETE HTTP request", err) return common.ErrHttpInternal } resp, err := httpClient.Do(req) if err != nil { - log.Println("DeleteAllReminders request: unexpected error happened on DELETE HTTP call", err) + logger.Log("DeleteAllReminders request: unexpected error happened on DELETE HTTP call", err) return common.ErrHttpOnCallingServer } if resp.StatusCode != http.StatusOK { - log.Println("DeleteAllReminders request: unexpected status code received: " + strconv.Itoa(resp.StatusCode)) + logger.Log("DeleteAllReminders request: unexpected status code received: " + strconv.Itoa(resp.StatusCode)) return common.ErrHttpOnDeletingAllReminders } return nil @@ -83,30 +83,30 @@ func DeleteAllReminders() error { func GetReminder(id int) (*common.Reminder, error) { resp, err := httpClient.Get(serverUrl + "/api/v1/reminders/" + strconv.Itoa(id)) if err != nil { - log.Println("GetReminder request: unexpected error happened on GET HTTP call", err) + logger.Log("GetReminder request: unexpected error happened on GET HTTP call", err) return nil, common.ErrHttpOnCallingServer } defer resp.Body.Close() if resp.StatusCode == http.StatusNotFound { - log.Println("GetReminder request: reminder not found by ID: "+strconv.Itoa(id), err) + logger.Log("GetReminder request: reminder not found by ID: "+strconv.Itoa(id), err) return nil, common.ErrHttpReminderNotFound } if resp.StatusCode != http.StatusOK { - log.Println("GetReminder request: unexpected status code received: " + strconv.Itoa(resp.StatusCode)) + logger.Log("GetReminder request: unexpected status code received: " + strconv.Itoa(resp.StatusCode)) return nil, common.ErrHttpOnGettingReminderById } respBody, err := io.ReadAll(resp.Body) if err != nil { - log.Println("GetReminder request: unexpected error happened on response body reading", err) + logger.Log("GetReminder request: unexpected error happened on response body reading", err) return nil, common.ErrHttpInternal } reminder := common.Reminder{} err = json.Unmarshal(respBody, &reminder) if err != nil { - log.Println("GetReminder request: unexpected error happened on response body decoding", err) + logger.Log("GetReminder request: unexpected error happened on response body decoding", err) return nil, common.ErrHttpInternal } return &reminder, err @@ -115,21 +115,21 @@ func GetReminder(id int) (*common.Reminder, error) { func DeleteReminder(id int) error { req, err := http.NewRequest(http.MethodDelete, serverUrl+"/api/v1/reminders/"+strconv.Itoa(id), nil) if err != nil { - log.Println("DeleteReminder request: unexpected error happened on preparing DELETE HTTP request", err) + logger.Log("DeleteReminder request: unexpected error happened on preparing DELETE HTTP request", err) return common.ErrHttpInternal } resp, err := httpClient.Do(req) if err != nil { - log.Println("DeleteReminder request: unexpected error happened on DELETE HTTP call", err) + logger.Log("DeleteReminder request: unexpected error happened on DELETE HTTP call", err) return common.ErrHttpOnCallingServer } if resp.StatusCode == http.StatusNotFound { - log.Println("DeleteReminder request: reminder not found by ID: "+strconv.Itoa(id), err) + logger.Log("DeleteReminder request: reminder not found by ID: "+strconv.Itoa(id), err) return common.ErrHttpReminderNotFound } if resp.StatusCode != http.StatusOK { - log.Println("DeleteReminder request: unexpected status code received: " + strconv.Itoa(resp.StatusCode)) + logger.Log("DeleteReminder request: unexpected status code received: " + strconv.Itoa(resp.StatusCode)) return common.ErrHttpOnDeletingReminder } return nil @@ -138,23 +138,23 @@ func DeleteReminder(id int) error { func ChangeReminder(id int, reminderModifications common.Reminder) error { reqBody, err := json.Marshal(reminderModifications) if err != nil { - log.Println("ChangeReminder request: unexpected error happened on encoding request body", err) + logger.Log("ChangeReminder request: unexpected error happened on encoding request body", err) return common.ErrHttpInternal } req, err := http.NewRequest(http.MethodPut, serverUrl+"/api/v1/reminders/"+strconv.Itoa(id), bytes.NewReader(reqBody)) if err != nil { - log.Println("ChangeReminder request: unexpected error happened on preparing PUT HTTP request", err) + logger.Log("ChangeReminder request: unexpected error happened on preparing PUT HTTP request", err) return common.ErrHttpInternal } resp, err := httpClient.Do(req) if err != nil { - log.Println("ChangeReminder request: unexpected error happened on PUT HTTP call", err) + logger.Log("ChangeReminder request: unexpected error happened on PUT HTTP call", err) return common.ErrHttpOnCallingServer } if resp.StatusCode != http.StatusOK { - log.Println("ChangeReminder request: unexpected status code received: " + strconv.Itoa(resp.StatusCode)) + logger.Log("ChangeReminder request: unexpected status code received: " + strconv.Itoa(resp.StatusCode)) return common.ErrHttpOnChangingReminder } return nil @@ -163,7 +163,7 @@ func ChangeReminder(id int, reminderModifications common.Reminder) error { func Healthcheck() bool { resp, err := httpClient.Get(serverUrl + "/healthcheck") if err != nil { - log.Println("Healthcheck request: unexpected error happened on GET HTTP call", err) + logger.Log("Healthcheck request: unexpected error happened on GET HTTP call", err) return false } defer resp.Body.Close() @@ -174,17 +174,17 @@ func Healthcheck() bool { func StopServer() error { req, err := http.NewRequest(http.MethodDelete, serverUrl+"/shutdown", nil) if err != nil { - log.Println("StopServer request: unexpected error happened on preparing DELETE HTTP request", err) + logger.Log("StopServer request: unexpected error happened on preparing DELETE HTTP request", err) return common.ErrHttpInternal } resp, err := httpClient.Do(req) if err != nil { - log.Println("StopServer request: unexpected error happened on DELETE HTTP call", err) + logger.Log("StopServer request: unexpected error happened on DELETE HTTP call", err) return common.ErrHttpOnCallingServer } if resp.StatusCode != http.StatusOK { - log.Println("StopServer request: unexpected status code received: " + strconv.Itoa(resp.StatusCode)) + logger.Log("StopServer request: unexpected status code received: " + strconv.Itoa(resp.StatusCode)) return common.ErrHttpOnTerminatingApp } return nil diff --git a/httpserver/api/router.go b/httpserver/api/router.go index ac8835e..f75a7d8 100644 --- a/httpserver/api/router.go +++ b/httpserver/api/router.go @@ -4,9 +4,9 @@ import ( "encoding/json" "errors" "github.com/go-chi/chi/v5" - "log" "n0rdy.me/remindme/common" "n0rdy.me/remindme/httpserver/service" + "n0rdy.me/remindme/logger" "net/http" "strconv" ) @@ -41,21 +41,21 @@ func (rmr *RemindMeRouter) NewRouter() *chi.Mux { } func (rmr *RemindMeRouter) getAllReminders(w http.ResponseWriter, req *http.Request) { - log.Println("getAllReminders request: received") + logger.Log("getAllReminders request: received") reminders := rmr.service.GetAll() rmr.sendJsonResponse(w, http.StatusOK, reminders) - log.Println("getAllReminders request: successfully processed") + logger.Log("getAllReminders request: successfully processed") } func (rmr *RemindMeRouter) createNewReminder(w http.ResponseWriter, req *http.Request) { - log.Println("createNewReminder request: received") + logger.Log("createNewReminder request: received") var reminder common.Reminder err := json.NewDecoder(req.Body).Decode(&reminder) if err != nil { - log.Println("createNewReminder request: unexpected error happened on request body decoding", err) + logger.Log("createNewReminder request: unexpected error happened on request body decoding", err) rmr.sendErrorResponse(w, http.StatusBadRequest, common.ErrCodeRequestBody) return } @@ -63,66 +63,66 @@ func (rmr *RemindMeRouter) createNewReminder(w http.ResponseWriter, req *http.Re rmr.service.Set(reminder) rmr.sendOkEmptyResponse(w) - log.Println("createNewReminder request: successfully processed") + logger.Log("createNewReminder request: successfully processed") } func (rmr *RemindMeRouter) deleteAllReminders(w http.ResponseWriter, req *http.Request) { - log.Println("deleteAllReminders request: received") + logger.Log("deleteAllReminders request: received") rmr.service.CancelAll() rmr.sendOkEmptyResponse(w) - log.Println("deleteAllReminders request: successfully processed") + logger.Log("deleteAllReminders request: successfully processed") } func (rmr *RemindMeRouter) getReminder(w http.ResponseWriter, req *http.Request) { - log.Println("getReminder request: received") + logger.Log("getReminder request: received") id, err := rmr.getId(req) if err != nil { - log.Println("getReminder request: error on parsing reminder ID from the URL param", err) + logger.Log("getReminder request: error on parsing reminder ID from the URL param", err) rmr.sendErrorResponse(w, http.StatusBadRequest, err.Error()) return } reminder := rmr.service.Get(id) if reminder == nil { - log.Println("getReminder request: reminder not found by ID " + strconv.Itoa(id)) + logger.Log("getReminder request: reminder not found by ID " + strconv.Itoa(id)) rmr.sendErrorResponse(w, http.StatusNotFound, common.ErrCodeReminderNotFound) return } rmr.sendJsonResponse(w, http.StatusOK, *reminder) - log.Println("getReminder request: successfully processed") + logger.Log("getReminder request: successfully processed") } func (rmr *RemindMeRouter) deleteReminder(w http.ResponseWriter, req *http.Request) { - log.Println("deleteReminder request: received") + logger.Log("deleteReminder request: received") id, err := rmr.getId(req) if err != nil { - log.Println("deleteReminder request: error on parsing reminder ID from the URL param", err) + logger.Log("deleteReminder request: error on parsing reminder ID from the URL param", err) rmr.sendErrorResponse(w, http.StatusBadRequest, err.Error()) return } canceled := rmr.service.Cancel(id) if !canceled { - log.Println("deleteReminder request: reminder not found by ID " + strconv.Itoa(id)) + logger.Log("deleteReminder request: reminder not found by ID " + strconv.Itoa(id)) rmr.sendErrorResponse(w, http.StatusNotFound, common.ErrCodeReminderNotFound) return } rmr.sendOkEmptyResponse(w) - log.Println("deleteReminder request: successfully processed") + logger.Log("deleteReminder request: successfully processed") } func (rmr *RemindMeRouter) changeReminder(w http.ResponseWriter, req *http.Request) { - log.Println("changeReminder request: received") + logger.Log("changeReminder request: received") id, err := rmr.getId(req) if err != nil { - log.Println("changeReminder request: error on parsing reminder ID from the URL param", err) + logger.Log("changeReminder request: error on parsing reminder ID from the URL param", err) rmr.sendErrorResponse(w, http.StatusBadRequest, err.Error()) return } @@ -130,7 +130,7 @@ func (rmr *RemindMeRouter) changeReminder(w http.ResponseWriter, req *http.Reque var reminder common.Reminder err = json.NewDecoder(req.Body).Decode(&reminder) if err != nil { - log.Println("changeReminder request: unexpected error happened on request body decoding", err) + logger.Log("changeReminder request: unexpected error happened on request body decoding", err) rmr.sendErrorResponse(w, http.StatusBadRequest, common.ErrCodeRequestBody) return } @@ -138,24 +138,24 @@ func (rmr *RemindMeRouter) changeReminder(w http.ResponseWriter, req *http.Reque rmr.service.Change(id, reminder) rmr.sendOkEmptyResponse(w) - log.Println("changeReminder request: successfully processed") + logger.Log("changeReminder request: successfully processed") } func (rmr *RemindMeRouter) shutdown(w http.ResponseWriter, req *http.Request) { - log.Println("shutdown request: received") + logger.Log("shutdown request: received") rmr.shutdownCh <- struct{}{} rmr.sendOkEmptyResponse(w) - log.Println("shutdown request: successfully processed") + logger.Log("shutdown request: successfully processed") } func (rmr *RemindMeRouter) healthCheck(w http.ResponseWriter, req *http.Request) { - log.Println("healthCheck request: received") + logger.Log("healthCheck request: received") rmr.sendJsonResponse(w, http.StatusOK, common.HealthcheckOk()) - log.Println("healthCheck request: successfully processed") + logger.Log("healthCheck request: successfully processed") } func (rmr *RemindMeRouter) sendOkEmptyResponse(w http.ResponseWriter) { diff --git a/httpserver/httpserver.go b/httpserver/httpserver.go index 78797a5..d4e47d5 100644 --- a/httpserver/httpserver.go +++ b/httpserver/httpserver.go @@ -3,11 +3,11 @@ package httpserver import ( "context" "fmt" - "log" "n0rdy.me/remindme/common" "n0rdy.me/remindme/httpserver/api" "n0rdy.me/remindme/httpserver/repo" "n0rdy.me/remindme/httpserver/service" + "n0rdy.me/remindme/logger" "n0rdy.me/remindme/utils" "net/http" "time" @@ -16,11 +16,11 @@ import ( func Start() { port := "15555" - logsFile, err := utils.SetupLogger(common.ServerLogsFileName) + err := logger.SetupLogger(utils.GetOsSpecificLogsDir(), common.ServerLogsFileName) if err != nil { fmt.Println("setting up logger failed", err) } else { - defer logsFile.Close() + defer logger.Close() } shutdownCh := make(chan struct{}) @@ -28,14 +28,14 @@ func Start() { remindMeRouter := api.NewRemindMeRouter(&srv, shutdownCh) httpRouter := remindMeRouter.NewRouter() - log.Println("http: starting server at port " + port) + logger.Log("http: starting server at port " + port) server := &http.Server{Addr: ":" + port, Handler: httpRouter} go func() { err := server.ListenAndServe() if err != nil { close(shutdownCh) - log.Println(err) + logger.Log("server shutdown", err) } }() @@ -49,7 +49,7 @@ func Start() { }() for range shutdownCh { - log.Println("server shutdown requested") + logger.Log("server shutdown requested") err := server.Shutdown(context.Background()) if err != nil { err := server.Close() diff --git a/httpserver/service/service.go b/httpserver/service/service.go index feeff83..6525772 100644 --- a/httpserver/service/service.go +++ b/httpserver/service/service.go @@ -1,11 +1,11 @@ package service import ( - "log" "n0rdy.me/remindme/common" "n0rdy.me/remindme/httpserver/repo" "n0rdy.me/remindme/httpserver/service/idresolver" "n0rdy.me/remindme/httpserver/service/notification" + "n0rdy.me/remindme/logger" "strconv" "time" ) @@ -69,7 +69,7 @@ func (rs *ReminderService) Change(reminderId int, reminder common.Reminder) { // in case if the the reminder wasn't deleted (e.g. due to the error) func (rs *ReminderService) DeleteExpiredReminders() { - log.Println("deleteExpiredReminders job: invoked") + logger.Log("deleteExpiredReminders job: invoked") now := time.Now() @@ -79,14 +79,14 @@ func (rs *ReminderService) DeleteExpiredReminders() { delete(rs.rmdIdToTimer, id) } - log.Println("deleteExpiredReminders job: finished") + logger.Log("deleteExpiredReminders job: finished") } func (rs *ReminderService) setTimer(reminder common.Reminder) { reminderTimer := time.AfterFunc(reminder.RemindAt.Sub(time.Now()), func() { err := rs.notifier.Notify(reminder) if err != nil { - log.Println("error happened on trying to send a notification for the reminder "+strconv.Itoa(reminder.ID), err) + logger.Log("error happened on trying to send a notification for the reminder "+strconv.Itoa(reminder.ID), err) } rs.repo.Delete(reminder.ID) delete(rs.rmdIdToTimer, reminder.ID) diff --git a/logger/logger.go b/logger/logger.go new file mode 100644 index 0000000..713104b --- /dev/null +++ b/logger/logger.go @@ -0,0 +1,42 @@ +package logger + +import ( + "log" + "os" +) + +var isLoggerSetUp bool +var fileWithLogs *os.File + +func SetupLogger(logsDir string, logsFile string) error { + if logsDir != "" { + err := os.MkdirAll(logsDir, os.ModePerm) + if err != nil { + return err + } + } + + f, err := os.OpenFile(logsDir+logsFile, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0644) + if err != nil { + return err + } + + log.SetOutput(f) + isLoggerSetUp = true + fileWithLogs = f + + return nil +} + +func Log(message string, err ...error) { + if isLoggerSetUp { + log.Println(message, err) + } +} + +func Close() error { + if fileWithLogs != nil { + return fileWithLogs.Close() + } + return nil +} diff --git a/main.go b/main.go index 660d870..859ab18 100644 --- a/main.go +++ b/main.go @@ -4,15 +4,16 @@ import ( "fmt" "n0rdy.me/remindme/cmd" "n0rdy.me/remindme/common" + "n0rdy.me/remindme/logger" "n0rdy.me/remindme/utils" ) func main() { - logsFile, err := utils.SetupLogger(common.ClientLogsFileName) + err := logger.SetupLogger(utils.GetOsSpecificLogsDir(), common.ClientLogsFileName) if err != nil { fmt.Println("setting up logger failed", err) } else { - defer logsFile.Close() + defer logger.Close() } cmd.Execute() diff --git a/utils/datetime.go b/utils/datetime.go index 306cdfd..6484070 100644 --- a/utils/datetime.go +++ b/utils/datetime.go @@ -1,8 +1,8 @@ package utils import ( - "log" "n0rdy.me/remindme/common" + "n0rdy.me/remindme/logger" "time" ) @@ -16,13 +16,13 @@ func TimeFrom24HoursString(timeAs24HoursString string) (time.Time, error) { parsedTime, err := time.Parse(common.TimeFormat24Hours, timeAs24HoursString+":00") if err != nil { - log.Println("error while parsing time in 24 hours string format: "+timeAs24HoursString, err) + logger.Log("error while parsing time in 24 hours string format: "+timeAs24HoursString, err) return now, common.ErrCmdWrongFormatted24HoursTime } parsedTime = time.Date(now.Year(), now.Month(), now.Day(), parsedTime.Hour(), parsedTime.Minute(), parsedTime.Second(), 0, time.Local) if parsedTime.Before(now) || parsedTime.Equal(now) { - log.Println("error while parsing time in 24 hours string format: " + timeAs24HoursString + " - time should be in future") + logger.Log("error while parsing time in 24 hours string format: " + timeAs24HoursString + " - time should be in future") return now, common.ErrCmdTimeShouldBeInFuture } @@ -34,13 +34,13 @@ func TimeFrom12HoursAmPmString(timeAs12HoursAmPmString string, amOrPm string) (t parsedTime, err := time.Parse(common.TimeFormat12AmPmHours, timeAs12HoursAmPmString+" "+amOrPm) if err != nil { - log.Println("error while parsing time in 12 hours string format: "+timeAs12HoursAmPmString, err) + logger.Log("error while parsing time in 12 hours string format: "+timeAs12HoursAmPmString, err) return now, common.ErrCmdWrongFormatted12HoursAmPmTime } parsedTime = time.Date(now.Year(), now.Month(), now.Day(), parsedTime.Hour(), parsedTime.Minute(), 0, 0, time.Local) if parsedTime.Before(now) || parsedTime.Equal(now) { - log.Println("error while parsing time in 12 hours string format: " + timeAs12HoursAmPmString + " - time should be in future") + logger.Log("error while parsing time in 12 hours string format: " + timeAs12HoursAmPmString + " - time should be in future") return now, common.ErrCmdTimeShouldBeInFuture } diff --git a/utils/logger.go b/utils/logger.go deleted file mode 100644 index 9b25ae3..0000000 --- a/utils/logger.go +++ /dev/null @@ -1,27 +0,0 @@ -package utils - -import ( - "fmt" - "log" - "os" -) - -func SetupLogger(logsFile string) (*os.File, error) { - logsDir := GetOsSpecificLogsDir() - - if logsDir != "" { - err := os.MkdirAll(logsDir, os.ModePerm) - if err != nil { - fmt.Println("creating logs directory failed - the current directory will be used instead", err) - logsDir = "" - } - } - - f, err := os.OpenFile(logsDir+logsFile, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0644) - if err != nil { - return nil, err - } - - log.SetOutput(f) - return f, nil -}