From 70bfcfef42578079f211d87cddc49519ee3503dc Mon Sep 17 00:00:00 2001 From: Moritz Poldrack Date: Sun, 31 Jul 2022 15:15:27 +0200 Subject: [PATCH] lint: work nicely with wrapped errors (errorlint) Error wrapping as introduced in Go 1.13 adds some additional logic to use for comparing errors and adding information to it. Signed-off-by: Moritz Poldrack Acked-by: Robin Jarry --- commands/move-tab.go | 2 +- commands/msg/forward.go | 2 +- completer/completer.go | 11 +++-- config/config.go | 8 ++-- lib/crypto/gpg/gpgbin/encrypt.go | 2 +- lib/crypto/gpg/gpgbin/sign.go | 2 +- lib/crypto/gpg/reader.go | 22 ++++----- lib/crypto/pgp/pgp.go | 8 ++-- lib/oauthbearer.go | 2 +- widgets/account.go | 2 +- widgets/aerc.go | 2 +- widgets/compose.go | 8 ++-- worker/imap/configure.go | 18 +++---- worker/imap/fetch.go | 4 +- worker/imap/worker.go | 2 +- worker/lib/parse.go | 26 +++++------ worker/maildir/container.go | 6 +-- worker/maildir/message.go | 4 +- worker/maildir/worker.go | 80 ++++++++++++++++---------------- worker/mbox/io.go | 3 +- worker/mbox/models.go | 2 +- worker/mbox/worker.go | 27 +++++------ worker/notmuch/lib/database.go | 5 +- worker/notmuch/message.go | 2 +- worker/notmuch/worker.go | 67 +++++++++++++------------- worker/types/thread.go | 4 +- 26 files changed, 163 insertions(+), 158 deletions(-) diff --git a/commands/move-tab.go b/commands/move-tab.go index 8648ed3..76e5348 100644 --- a/commands/move-tab.go +++ b/commands/move-tab.go @@ -31,7 +31,7 @@ func (MoveTab) Execute(aerc *widgets.Aerc, args []string) error { n, err := strconv.Atoi(joinedArgs) if err != nil { - return fmt.Errorf("failed to parse index argument: %v", err) + return fmt.Errorf("failed to parse index argument: %w", err) } var relative bool diff --git a/commands/msg/forward.go b/commands/msg/forward.go index ddc2791..d89667a 100644 --- a/commands/msg/forward.go +++ b/commands/msg/forward.go @@ -85,7 +85,7 @@ func (forward) Execute(aerc *widgets.Aerc, args []string) error { if strings.Contains(to, "@") { tolist, err = mail.ParseAddressList(to) if err != nil { - return fmt.Errorf("invalid to address(es): %v", err) + return fmt.Errorf("invalid to address(es): %w", err) } } if len(tolist) > 0 { diff --git a/completer/completer.go b/completer/completer.go index c5624f9..202607a 100644 --- a/completer/completer.go +++ b/completer/completer.go @@ -2,6 +2,7 @@ package completer import ( "bufio" + "errors" "fmt" "io" "io/ioutil" @@ -82,14 +83,14 @@ func (c *Completer) completeAddress(s string) ([]string, string, error) { } stdout, err := cmd.StdoutPipe() if err != nil { - return nil, "", fmt.Errorf("stdout: %v", err) + return nil, "", fmt.Errorf("stdout: %w", err) } stderr, err := cmd.StderrPipe() if err != nil { - return nil, "", fmt.Errorf("stderr: %v", err) + return nil, "", fmt.Errorf("stderr: %w", err) } if err := cmd.Start(); err != nil { - return nil, "", fmt.Errorf("cmd start: %v", err) + return nil, "", fmt.Errorf("cmd start: %w", err) } // Wait returns an error if the exit status != 0, which some completion // programs will do to signal no matches. We don't want to spam the user with @@ -104,7 +105,7 @@ func (c *Completer) completeAddress(s string) ([]string, string, error) { if msg != "" { msg = ": " + msg } - return nil, "", fmt.Errorf("read completions%s: %v", msg, err) + return nil, "", fmt.Errorf("read completions%s: %w", msg, err) } return completions, prefix, nil @@ -150,7 +151,7 @@ func readCompletions(r io.Reader) ([]string, error) { completions := []string{} for { line, err := buf.ReadString('\n') - if err == io.EOF { + if errors.Is(err, io.EOF) { return completions, nil } else if err != nil { return nil, err diff --git a/config/config.go b/config/config.go index de34e43..66c6dd1 100644 --- a/config/config.go +++ b/config/config.go @@ -128,7 +128,7 @@ func (c RemoteConfig) ConnectionString() (string, error) { cmd.Stdin = os.Stdin output, err := cmd.Output() if err != nil { - return "", fmt.Errorf("failed to read password: %s", err) + return "", fmt.Errorf("failed to read password: %w", err) } pw := strings.TrimSpace(string(output)) @@ -344,13 +344,13 @@ func loadAccountConfig(path string) ([]AccountConfig, error) { source, err := sourceRemoteConfig.ConnectionString() if err != nil { - return nil, fmt.Errorf("Invalid source credentials for %s: %s", _sec, err) + return nil, fmt.Errorf("Invalid source credentials for %s: %w", _sec, err) } account.Source = source _, err = account.Outgoing.parseValue() if err != nil { - return nil, fmt.Errorf("Invalid outgoing credentials for %s: %s", _sec, err) + return nil, fmt.Errorf("Invalid outgoing credentials for %s: %w", _sec, err) } accounts = append(accounts, account) @@ -1027,7 +1027,7 @@ func (ui *UIConfig) loadStyleSet(styleSetDirs []string) error { ui.style = NewStyleSet() err := ui.style.LoadStyleSet(ui.StyleSetName, styleSetDirs) if err != nil { - return fmt.Errorf("Unable to load default styleset: %s", err) + return fmt.Errorf("Unable to load default styleset: %w", err) } return nil diff --git a/lib/crypto/gpg/gpgbin/encrypt.go b/lib/crypto/gpg/gpgbin/encrypt.go index 9ca4526..79003fd 100644 --- a/lib/crypto/gpg/gpgbin/encrypt.go +++ b/lib/crypto/gpg/gpgbin/encrypt.go @@ -33,7 +33,7 @@ func Encrypt(r io.Reader, to []string, from string) ([]byte, error) { var md models.MessageDetails err = parse(outRdr, &md) if err != nil { - return nil, fmt.Errorf("gpg: failure to encrypt: %v. check public key(s)", err) + return nil, fmt.Errorf("gpg: failure to encrypt: %w. check public key(s)", err) } var buf bytes.Buffer _, _ = io.Copy(&buf, md.Body) diff --git a/lib/crypto/gpg/gpgbin/sign.go b/lib/crypto/gpg/gpgbin/sign.go index caf31d1..314c3fc 100644 --- a/lib/crypto/gpg/gpgbin/sign.go +++ b/lib/crypto/gpg/gpgbin/sign.go @@ -26,7 +26,7 @@ func Sign(r io.Reader, from string) ([]byte, string, error) { var md models.MessageDetails err = parse(outRdr, &md) if err != nil { - return nil, "", fmt.Errorf("failed to parse messagedetails: %v", err) + return nil, "", fmt.Errorf("failed to parse messagedetails: %w", err) } var buf bytes.Buffer _, _ = io.Copy(&buf, md.Body) diff --git a/lib/crypto/gpg/reader.go b/lib/crypto/gpg/reader.go index 40da82f..07553c9 100644 --- a/lib/crypto/gpg/reader.go +++ b/lib/crypto/gpg/reader.go @@ -61,12 +61,12 @@ func Read(r io.Reader) (*Reader, error) { func newEncryptedReader(h textproto.Header, mr *textproto.MultipartReader) (*Reader, error) { p, err := mr.NextPart() if err != nil { - return nil, fmt.Errorf("gpgmail: failed to read first part in multipart/encrypted message: %v", err) + return nil, fmt.Errorf("gpgmail: failed to read first part in multipart/encrypted message: %w", err) } t, _, err := mime.ParseMediaType(p.Header.Get("Content-Type")) if err != nil { - return nil, fmt.Errorf("gpgmail: failed to parse Content-Type of first part in multipart/encrypted message: %v", err) + return nil, fmt.Errorf("gpgmail: failed to parse Content-Type of first part in multipart/encrypted message: %w", err) } if !strings.EqualFold(t, "application/pgp-encrypted") { return nil, fmt.Errorf("gpgmail: first part in multipart/encrypted message has type %q, not application/pgp-encrypted", t) @@ -74,7 +74,7 @@ func newEncryptedReader(h textproto.Header, mr *textproto.MultipartReader) (*Rea metadata, err := textproto.ReadHeader(bufio.NewReader(p)) if err != nil { - return nil, fmt.Errorf("gpgmail: failed to parse application/pgp-encrypted part: %v", err) + return nil, fmt.Errorf("gpgmail: failed to parse application/pgp-encrypted part: %w", err) } if s := metadata.Get("Version"); s != "1" { return nil, fmt.Errorf("gpgmail: unsupported PGP/MIME version: %q", s) @@ -82,11 +82,11 @@ func newEncryptedReader(h textproto.Header, mr *textproto.MultipartReader) (*Rea p, err = mr.NextPart() if err != nil { - return nil, fmt.Errorf("gpgmail: failed to read second part in multipart/encrypted message: %v", err) + return nil, fmt.Errorf("gpgmail: failed to read second part in multipart/encrypted message: %w", err) } t, _, err = mime.ParseMediaType(p.Header.Get("Content-Type")) if err != nil { - return nil, fmt.Errorf("gpgmail: failed to parse Content-Type of second part in multipart/encrypted message: %v", err) + return nil, fmt.Errorf("gpgmail: failed to parse Content-Type of second part in multipart/encrypted message: %w", err) } if !strings.EqualFold(t, "application/octet-stream") { return nil, fmt.Errorf("gpgmail: second part in multipart/encrypted message has type %q, not application/octet-stream", t) @@ -94,13 +94,13 @@ func newEncryptedReader(h textproto.Header, mr *textproto.MultipartReader) (*Rea md, err := gpgbin.Decrypt(p) if err != nil { - return nil, fmt.Errorf("gpgmail: failed to read PGP message: %v", err) + return nil, fmt.Errorf("gpgmail: failed to read PGP message: %w", err) } cleartext := bufio.NewReader(md.Body) cleartextHeader, err := textproto.ReadHeader(cleartext) if err != nil { - return nil, fmt.Errorf("gpgmail: failed to read encrypted header: %v", err) + return nil, fmt.Errorf("gpgmail: failed to read encrypted header: %w", err) } t, params, err := mime.ParseMediaType(cleartextHeader.Get("Content-Type")) @@ -114,7 +114,7 @@ func newEncryptedReader(h textproto.Header, mr *textproto.MultipartReader) (*Rea mr := textproto.NewMultipartReader(cleartext, params["boundary"]) mds, err := newSignedReader(cleartextHeader, mr, micalg) if err != nil { - return nil, fmt.Errorf("gpgmail: failed to read encapsulated multipart/signed message: %v", err) + return nil, fmt.Errorf("gpgmail: failed to read encapsulated multipart/signed message: %w", err) } mds.MessageDetails.IsEncrypted = md.IsEncrypted mds.MessageDetails.DecryptedWith = md.DecryptedWith @@ -136,7 +136,7 @@ func newSignedReader(h textproto.Header, mr *textproto.MultipartReader, micalg s micalg = strings.ToLower(micalg) p, err := mr.NextPart() if err != nil { - return nil, fmt.Errorf("gpgmail: failed to read signed part in multipart/signed message: %v", err) + return nil, fmt.Errorf("gpgmail: failed to read signed part in multipart/signed message: %w", err) } var headerBuf bytes.Buffer _ = textproto.WriteHeader(&headerBuf, p.Header) @@ -147,12 +147,12 @@ func newSignedReader(h textproto.Header, mr *textproto.MultipartReader, micalg s sig, err := mr.NextPart() if err != nil { - return nil, fmt.Errorf("gpgmail: failed to read pgp part in multipart/signed message: %v", err) + return nil, fmt.Errorf("gpgmail: failed to read pgp part in multipart/signed message: %w", err) } md, err := gpgbin.Verify(&msg, sig) if err != nil { - return nil, fmt.Errorf("gpgmail: failed to read PGP message: %v", err) + return nil, fmt.Errorf("gpgmail: failed to read PGP message: %w", err) } if md.Micalg != micalg && md.SignatureError == "" { md.SignatureError = "gpg: header hash does not match actual sig hash" diff --git a/lib/crypto/pgp/pgp.go b/lib/crypto/pgp/pgp.go index 579395f..689bae3 100644 --- a/lib/crypto/pgp/pgp.go +++ b/lib/crypto/pgp/pgp.go @@ -33,7 +33,7 @@ func (m *Mail) Init() error { logging.Infof("Initializing PGP keyring") err := os.MkdirAll(path.Join(xdg.DataHome(), "aerc"), 0o700) if err != nil { - return fmt.Errorf("failed to create data directory: %v", err) + return fmt.Errorf("failed to create data directory: %w", err) } lockpath := path.Join(xdg.DataHome(), "aerc", "keyring.lock") @@ -290,16 +290,16 @@ func (m *Mail) ExportKey(k string) (io.Reader, error) { pks := bytes.NewBuffer(nil) err = entity.Serialize(pks) if err != nil { - return nil, fmt.Errorf("pgp: error exporting key: %v", err) + return nil, fmt.Errorf("pgp: error exporting key: %w", err) } pka := bytes.NewBuffer(nil) w, err := armor.Encode(pka, "PGP PUBLIC KEY BLOCK", map[string]string{}) if err != nil { - return nil, fmt.Errorf("pgp: error exporting key: %v", err) + return nil, fmt.Errorf("pgp: error exporting key: %w", err) } _, err = w.Write(pks.Bytes()) if err != nil { - return nil, fmt.Errorf("pgp: error exporting key: %v", err) + return nil, fmt.Errorf("pgp: error exporting key: %w", err) } w.Close() return pka, nil diff --git a/lib/oauthbearer.go b/lib/oauthbearer.go index 4954830..063866b 100644 --- a/lib/oauthbearer.go +++ b/lib/oauthbearer.go @@ -23,7 +23,7 @@ func (c *OAuthBearer) ExchangeRefreshToken(refreshToken string) (*oauth2.Token, func (c *OAuthBearer) Authenticate(username string, password string, client *client.Client) error { if ok, err := client.SupportAuth(sasl.OAuthBearer); err != nil || !ok { - return fmt.Errorf("OAuthBearer not supported %v", err) + return fmt.Errorf("OAuthBearer not supported %w", err) } if c.OAuth2.Endpoint.TokenURL != "" { diff --git a/widgets/account.go b/widgets/account.go index 4f25f77..ceb8d98 100644 --- a/widgets/account.go +++ b/widgets/account.go @@ -404,7 +404,7 @@ func (acct *AccountView) GetSortCriteria() []*types.SortCriterion { } criteria, err := sort.GetSortCriteria(acct.UiConfig().Sort) if err != nil { - acct.PushError(fmt.Errorf("ui sort: %v", err)) + acct.PushError(fmt.Errorf("ui sort: %w", err)) return nil } return criteria diff --git a/widgets/aerc.go b/widgets/aerc.go index fbbf2aa..2383973 100644 --- a/widgets/aerc.go +++ b/widgets/aerc.go @@ -536,7 +536,7 @@ func (aerc *Aerc) Mailto(addr *url.URL) error { h := &mail.Header{} to, err := mail.ParseAddressList(addr.Opaque) if err != nil && addr.Opaque != "" { - return fmt.Errorf("Could not parse to: %v", err) + return fmt.Errorf("Could not parse to: %w", err) } h.SetAddressList("to", to) for key, vals := range addr.Query() { diff --git a/widgets/compose.go b/widgets/compose.go index 3058429..670f4f2 100644 --- a/widgets/compose.go +++ b/widgets/compose.go @@ -202,7 +202,7 @@ func (c *Composer) SetAttachKey(attach bool) error { if found { err := c.DeleteAttachment(name) if err != nil { - return fmt.Errorf("failed to delete attachment '%s: %v", name, err) + return fmt.Errorf("failed to delete attachment '%s: %w", name, err) } } else { attach = !attach @@ -259,7 +259,7 @@ func (c *Composer) SetSign(sign bool) error { err := c.updateCrypto() if err != nil { c.sign = !sign - return fmt.Errorf("Cannot sign message: %v", err) + return fmt.Errorf("Cannot sign message: %w", err) } return nil } @@ -403,7 +403,7 @@ func (c *Composer) AddTemplate(template string, data interface{}) error { mr, err := mail.CreateReader(templateText) if err != nil { - return fmt.Errorf("Template loading failed: %v", err) + return fmt.Errorf("Template loading failed: %w", err) } // copy the headers contained in the template to the compose headers @@ -414,7 +414,7 @@ func (c *Composer) AddTemplate(template string, data interface{}) error { part, err := mr.NextPart() if err != nil { - return fmt.Errorf("Could not get body of template: %v", err) + return fmt.Errorf("Could not get body of template: %w", err) } c.AppendContents(part.Body) diff --git a/worker/imap/configure.go b/worker/imap/configure.go index f515188..691e0d7 100644 --- a/worker/imap/configure.go +++ b/worker/imap/configure.go @@ -65,7 +65,7 @@ func (w *IMAPWorker) handleConfigure(msg *types.Configure) error { val, err := time.ParseDuration(value) if err != nil || val < 0 { return fmt.Errorf( - "invalid idle-timeout value %v: %v", + "invalid idle-timeout value %v: %w", value, err) } w.config.idle_timeout = val @@ -73,7 +73,7 @@ func (w *IMAPWorker) handleConfigure(msg *types.Configure) error { val, err := time.ParseDuration(value) if err != nil || val < 0 { return fmt.Errorf( - "invalid idle-debounce value %v: %v", + "invalid idle-debounce value %v: %w", value, err) } w.config.idle_debounce = val @@ -81,7 +81,7 @@ func (w *IMAPWorker) handleConfigure(msg *types.Configure) error { val, err := time.ParseDuration(value) if err != nil || val < 0 { return fmt.Errorf( - "invalid reconnect-maxwait value %v: %v", + "invalid reconnect-maxwait value %v: %w", value, err) } w.config.reconnect_maxwait = val @@ -89,7 +89,7 @@ func (w *IMAPWorker) handleConfigure(msg *types.Configure) error { val, err := time.ParseDuration(value) if err != nil || val < 0 { return fmt.Errorf( - "invalid connection-timeout value %v: %v", + "invalid connection-timeout value %v: %w", value, err) } w.config.connection_timeout = val @@ -97,7 +97,7 @@ func (w *IMAPWorker) handleConfigure(msg *types.Configure) error { val, err := time.ParseDuration(value) if err != nil || val < 0 { return fmt.Errorf( - "invalid keepalive-period value %v: %v", + "invalid keepalive-period value %v: %w", value, err) } w.config.keepalive_period = val @@ -105,7 +105,7 @@ func (w *IMAPWorker) handleConfigure(msg *types.Configure) error { val, err := strconv.Atoi(value) if err != nil || val < 0 { return fmt.Errorf( - "invalid keepalive-probes value %v: %v", + "invalid keepalive-probes value %v: %w", value, err) } w.config.keepalive_probes = val @@ -113,7 +113,7 @@ func (w *IMAPWorker) handleConfigure(msg *types.Configure) error { val, err := time.ParseDuration(value) if err != nil || val < 0 { return fmt.Errorf( - "invalid keepalive-interval value %v: %v", + "invalid keepalive-interval value %v: %w", value, err) } w.config.keepalive_interval = int(val.Seconds()) @@ -123,13 +123,13 @@ func (w *IMAPWorker) handleConfigure(msg *types.Configure) error { // Return an error here because the user tried to set header // caching, and we want them to know they didn't set it right - // one way or the other - return fmt.Errorf("invalid cache-headers value %v: %v", value, err) + return fmt.Errorf("invalid cache-headers value %v: %w", value, err) } w.config.cacheEnabled = cache case "cache-max-age": val, err := time.ParseDuration(value) if err != nil || val < 0 { - return fmt.Errorf("invalid cache-max-age value %v: %v", value, err) + return fmt.Errorf("invalid cache-max-age value %v: %w", value, err) } w.config.cacheMaxAge = val } diff --git a/worker/imap/fetch.go b/worker/imap/fetch.go index 41269cb..f21c6e9 100644 --- a/worker/imap/fetch.go +++ b/worker/imap/fetch.go @@ -118,13 +118,13 @@ func (imapw *IMAPWorker) handleFetchMessageBodyPart( } h, err := textproto.ReadHeader(bufio.NewReader(body)) if err != nil { - return fmt.Errorf("failed to read part header: %v", err) + return fmt.Errorf("failed to read part header: %w", err) } part, err := message.New(message.Header{Header: h}, _msg.GetBody(&partBodySection)) if err != nil { - return fmt.Errorf("failed to create message reader: %v", err) + return fmt.Errorf("failed to create message reader: %w", err) } imapw.worker.PostMessage(&types.MessageBodyPart{ diff --git a/worker/imap/worker.go b/worker/imap/worker.go index 40debe6..6b6c926 100644 --- a/worker/imap/worker.go +++ b/worker/imap/worker.go @@ -282,7 +282,7 @@ func (w *IMAPWorker) Run() { case msg := <-w.worker.Actions: msg = w.worker.ProcessAction(msg) - if err := w.handleMessage(msg); err == errUnsupported { + if err := w.handleMessage(msg); errors.Is(err, errUnsupported) { w.worker.PostMessage(&types.Unsupported{ Message: types.RespondTo(msg), }, nil) diff --git a/worker/lib/parse.go b/worker/lib/parse.go index d92eeda..ad5e0a8 100644 --- a/worker/lib/parse.go +++ b/worker/lib/parse.go @@ -104,7 +104,7 @@ func ParseEntityStructure(e *message.Entity) (*models.BodyStructure, error) { if cd := e.Header.Get("content-disposition"); cd != "" { contentDisposition, cdParams, err := e.Header.ContentDisposition() if err != nil { - return nil, fmt.Errorf("could not parse content disposition: %v", err) + return nil, fmt.Errorf("could not parse content disposition: %w", err) } body.Disposition = contentDisposition body.DispositionParams = cdParams @@ -113,7 +113,7 @@ func ParseEntityStructure(e *message.Entity) (*models.BodyStructure, error) { if mpr := e.MultipartReader(); mpr != nil { for { part, err := mpr.NextPart() - if err == io.EOF { + if errors.Is(err, io.EOF) { return &body, nil } else if err != nil { return nil, err @@ -133,27 +133,27 @@ var DateParseError = errors.New("date parsing failed") func parseEnvelope(h *mail.Header) (*models.Envelope, error) { from, err := parseAddressList(h, "from") if err != nil { - return nil, fmt.Errorf("could not read from address: %v", err) + return nil, fmt.Errorf("could not read from address: %w", err) } to, err := parseAddressList(h, "to") if err != nil { - return nil, fmt.Errorf("could not read to address: %v", err) + return nil, fmt.Errorf("could not read to address: %w", err) } cc, err := parseAddressList(h, "cc") if err != nil { - return nil, fmt.Errorf("could not read cc address: %v", err) + return nil, fmt.Errorf("could not read cc address: %w", err) } bcc, err := parseAddressList(h, "bcc") if err != nil { - return nil, fmt.Errorf("could not read bcc address: %v", err) + return nil, fmt.Errorf("could not read bcc address: %w", err) } replyTo, err := parseAddressList(h, "reply-to") if err != nil { - return nil, fmt.Errorf("could not read reply-to address: %v", err) + return nil, fmt.Errorf("could not read reply-to address: %w", err) } subj, err := h.Subject() if err != nil { - return nil, fmt.Errorf("could not read subject: %v", err) + return nil, fmt.Errorf("could not read subject: %w", err) } msgID, err := h.MessageID() if err != nil { @@ -167,7 +167,7 @@ func parseEnvelope(h *mail.Header) (*models.Envelope, error) { if err != nil { // still return a valid struct plus a sentinel date parsing error // if only the date parsing failed - err = fmt.Errorf("%w: %v", DateParseError, err) + err = fmt.Errorf("%v: %w", DateParseError, err) } return &models.Envelope{ Date: date, @@ -217,7 +217,7 @@ func parseDate(h *mail.Header) (time.Time, error) { func parseReceivedHeader(h *mail.Header) (time.Time, error) { guess, err := h.Text("received") if err != nil { - return time.Time{}, fmt.Errorf("received header not parseable: %v", + return time.Time{}, fmt.Errorf("received header not parseable: %w", err) } return time.Parse(time.RFC1123Z, dateRe.FindString(guess)) @@ -254,18 +254,18 @@ func MessageInfo(raw RawMessage) (*models.MessageInfo, error) { defer r.Close() msg, err := message.Read(r) if err != nil { - return nil, fmt.Errorf("could not read message: %v", err) + return nil, fmt.Errorf("could not read message: %w", err) } bs, err := ParseEntityStructure(msg) if errors.As(err, new(message.UnknownEncodingError)) { parseErr = err } else if err != nil { - return nil, fmt.Errorf("could not get structure: %v", err) + return nil, fmt.Errorf("could not get structure: %w", err) } h := &mail.Header{Header: msg.Header} env, err := parseEnvelope(h) if err != nil && !errors.Is(err, DateParseError) { - return nil, fmt.Errorf("could not parse envelope: %v", err) + return nil, fmt.Errorf("could not parse envelope: %w", err) // if only the date parsing failed we still get the rest of the // envelop structure in a valid state. // Date parsing errors are fairly common and it's better to be diff --git a/worker/maildir/container.go b/worker/maildir/container.go index 3512577..a8ac1ac 100644 --- a/worker/maildir/container.go +++ b/worker/maildir/container.go @@ -50,7 +50,7 @@ func (c *Container) ListFolders() ([]string, error) { } err := filepath.Walk(c.dir, func(path string, info os.FileInfo, err error) error { if err != nil { - return fmt.Errorf("Invalid path '%s': error: %v", path, err) + return fmt.Errorf("Invalid path '%s': error: %w", path, err) } if !info.IsDir() { return nil @@ -144,7 +144,7 @@ func (c *Container) ClearRecentFlag(uid uint32) { func (c *Container) UIDs(d maildir.Dir) ([]uint32, error) { keys, err := d.Keys() if err != nil { - return nil, fmt.Errorf("could not get keys for %s: %v", d, err) + return nil, fmt.Errorf("could not get keys for %s: %w", d, err) } sort.Strings(keys) var uids []uint32 @@ -189,7 +189,7 @@ func (c *Container) CopyAll( ) error { for _, uid := range uids { if err := c.copyMessage(dest, src, uid); err != nil { - return fmt.Errorf("could not copy message %d: %v", uid, err) + return fmt.Errorf("could not copy message %d: %w", uid, err) } } return nil diff --git a/worker/maildir/message.go b/worker/maildir/message.go index b73e083..81573c5 100644 --- a/worker/maildir/message.go +++ b/worker/maildir/message.go @@ -46,7 +46,7 @@ func (m Message) SetFlags(flags []maildir.Flag) error { func (m Message) SetOneFlag(flag maildir.Flag, enable bool) error { flags, err := m.Flags() if err != nil { - return fmt.Errorf("could not read previous flags: %v", err) + return fmt.Errorf("could not read previous flags: %w", err) } if enable { flags = append(flags, flag) @@ -87,7 +87,7 @@ func (m Message) NewBodyPartReader(requestedParts []int) (io.Reader, error) { defer f.Close() msg, err := message.Read(f) if err != nil { - return nil, fmt.Errorf("could not read message: %v", err) + return nil, fmt.Errorf("could not read message: %w", err) } return lib.FetchEntityPartReader(msg, requestedParts) } diff --git a/worker/maildir/worker.go b/worker/maildir/worker.go index a770b2f..9f9fee9 100644 --- a/worker/maildir/worker.go +++ b/worker/maildir/worker.go @@ -46,7 +46,7 @@ type Worker struct { func NewWorker(worker *types.Worker) (types.Backend, error) { watch, err := fsnotify.NewWatcher() if err != nil { - return nil, fmt.Errorf("could not create file system watcher: %v", err) + return nil, fmt.Errorf("could not create file system watcher: %w", err) } return &Worker{worker: worker, watcher: watch}, nil } @@ -55,7 +55,7 @@ func NewWorker(worker *types.Worker) (types.Backend, error) { func NewMaildirppWorker(worker *types.Worker) (types.Backend, error) { watch, err := fsnotify.NewWatcher() if err != nil { - return nil, fmt.Errorf("could not create file system watcher: %v", err) + return nil, fmt.Errorf("could not create file system watcher: %w", err) } return &Worker{worker: worker, watcher: watch, maildirpp: true}, nil } @@ -112,18 +112,18 @@ func (w *Worker) handleFSEvent(ev fsnotify.Event) { } err := w.c.SyncNewMail(*w.selected) if err != nil { - logging.Errorf("could not move new to cur : %v", err) + logging.Errorf("could not move new to cur : %w", err) return } uids, err := w.c.UIDs(*w.selected) if err != nil { - logging.Errorf("could not scan UIDs: %v", err) + logging.Errorf("could not scan UIDs: %w", err) return } sortedUids, err := w.sort(uids, w.currentSortCriteria) if err != nil { - logging.Errorf("error sorting directory: %v", err) + logging.Errorf("error sorting directory: %w", err) return } w.worker.PostMessage(&types.DirectoryContents{ @@ -204,18 +204,18 @@ func (w *Worker) getDirectoryInfo(name string) *models.DirectoryInfo { for _, v := range files { key, flags, err := splitMaildirFile(v) if err != nil { - logging.Errorf("%q: error parsing flags (%q): %v", v, key, err) + logging.Errorf("%q: error parsing flags (%q): %w", v, key, err) continue } keyFlags[key] = flags } } else { - logging.Infof("disabled flags cache: %q: %v", dir, err) + logging.Infof("disabled flags cache: %q: %w", dir, err) } uids, err := w.c.UIDs(dir) if err != nil { - logging.Errorf("could not get uids: %v", err) + logging.Errorf("could not get uids: %w", err) return dirInfo } @@ -223,7 +223,7 @@ func (w *Worker) getDirectoryInfo(name string) *models.DirectoryInfo { for _, uid := range uids { message, err := w.c.Message(dir, uid) if err != nil { - logging.Errorf("could not get message: %v", err) + logging.Errorf("could not get message: %w", err) continue } var flags []maildir.Flag @@ -234,14 +234,14 @@ func (w *Worker) getDirectoryInfo(name string) *models.DirectoryInfo { logging.Debugf("message (key=%q uid=%d) not found in map cache", message.key, message.uid) flags, err = message.Flags() if err != nil { - logging.Errorf("could not get flags: %v", err) + logging.Errorf("could not get flags: %w", err) continue } } } else { flags, err = message.Flags() if err != nil { - logging.Errorf("could not get flags: %v", err) + logging.Errorf("could not get flags: %w", err) continue } } @@ -306,14 +306,14 @@ func (w *Worker) handleMessage(msg types.WorkerMessage) error { func (w *Worker) handleConfigure(msg *types.Configure) error { u, err := url.Parse(msg.Config.Source) if err != nil { - logging.Errorf("error configuring maildir worker: %v", err) + logging.Errorf("error configuring maildir worker: %w", err) return err } dir := u.Path if u.Host == "~" { home, err := os.UserHomeDir() if err != nil { - return fmt.Errorf("could not resolve home directory: %v", err) + return fmt.Errorf("could not resolve home directory: %w", err) } dir = filepath.Join(home, u.Path) } @@ -343,7 +343,7 @@ func (w *Worker) handleListDirectories(msg *types.ListDirectories) error { } dirs, err := w.c.ListFolders() if err != nil { - logging.Errorf("failed listing directories: %v", err) + logging.Errorf("failed listing directories: %w", err) return err } for _, name := range dirs { @@ -375,11 +375,11 @@ func (w *Worker) handleOpenDirectory(msg *types.OpenDirectory) error { if w.selected != nil { prevDir := filepath.Join(string(*w.selected), "new") if err := w.watcher.Remove(prevDir); err != nil { - return fmt.Errorf("could not unwatch previous directory: %v", err) + return fmt.Errorf("could not unwatch previous directory: %w", err) } prevDir = filepath.Join(string(*w.selected), "cur") if err := w.watcher.Remove(prevDir); err != nil { - return fmt.Errorf("could not unwatch previous directory: %v", err) + return fmt.Errorf("could not unwatch previous directory: %w", err) } } @@ -389,15 +389,15 @@ func (w *Worker) handleOpenDirectory(msg *types.OpenDirectory) error { // add watch paths newDir := filepath.Join(string(*w.selected), "new") if err := w.watcher.Add(newDir); err != nil { - return fmt.Errorf("could not add watch to directory: %v", err) + return fmt.Errorf("could not add watch to directory: %w", err) } newDir = filepath.Join(string(*w.selected), "cur") if err := w.watcher.Add(newDir); err != nil { - return fmt.Errorf("could not add watch to directory: %v", err) + return fmt.Errorf("could not add watch to directory: %w", err) } if err := dir.Clean(); err != nil { - return fmt.Errorf("could not clean directory: %v", err) + return fmt.Errorf("could not clean directory: %w", err) } info := &types.DirectoryInfo{ @@ -426,13 +426,13 @@ func (w *Worker) handleFetchDirectoryContents( } else { uids, err = w.c.UIDs(*w.selected) if err != nil { - logging.Errorf("failed scanning uids: %v", err) + logging.Errorf("failed scanning uids: %w", err) return err } } sortedUids, err := w.sort(uids, msg.SortCriteria) if err != nil { - logging.Errorf("failed sorting directory: %v", err) + logging.Errorf("failed sorting directory: %w", err) return err } w.currentSortCriteria = msg.SortCriteria @@ -451,14 +451,14 @@ func (w *Worker) sort(uids []uint32, criteria []*types.SortCriterion) ([]uint32, for _, uid := range uids { info, err := w.msgInfoFromUid(uid) if err != nil { - logging.Errorf("could not get message info: %v", err) + logging.Errorf("could not get message info: %w", err) continue } msgInfos = append(msgInfos, info) } sortedUids, err := lib.Sort(msgInfos, criteria) if err != nil { - logging.Errorf("could not sort the messages: %v", err) + logging.Errorf("could not sort the messages: %w", err) return nil, err } return sortedUids, nil @@ -467,7 +467,7 @@ func (w *Worker) sort(uids []uint32, criteria []*types.SortCriterion) ([]uint32, func (w *Worker) handleCreateDirectory(msg *types.CreateDirectory) error { dir := w.c.Dir(msg.Directory) if err := dir.Init(); err != nil { - logging.Errorf("could not create directory %s: %v", + logging.Errorf("could not create directory %s: %w", msg.Directory, err) return err } @@ -477,7 +477,7 @@ func (w *Worker) handleCreateDirectory(msg *types.CreateDirectory) error { func (w *Worker) handleRemoveDirectory(msg *types.RemoveDirectory) error { dir := w.c.Dir(msg.Directory) if err := os.RemoveAll(string(dir)); err != nil { - logging.Errorf("could not remove directory %s: %v", + logging.Errorf("could not remove directory %s: %w", msg.Directory, err) return err } @@ -490,7 +490,7 @@ func (w *Worker) handleFetchMessageHeaders( for _, uid := range msg.Uids { info, err := w.msgInfoFromUid(uid) if err != nil { - logging.Errorf("could not get message info: %v", err) + logging.Errorf("could not get message info: %w", err) w.err(msg, err) continue } @@ -509,13 +509,13 @@ func (w *Worker) handleFetchMessageBodyPart( // get reader m, err := w.c.Message(*w.selected, msg.Uid) if err != nil { - logging.Errorf("could not get message %d: %v", msg.Uid, err) + logging.Errorf("could not get message %d: %w", msg.Uid, err) return err } r, err := m.NewBodyPartReader(msg.Part) if err != nil { logging.Errorf( - "could not get body part reader for message=%d, parts=%#v: %v", + "could not get body part reader for message=%d, parts=%#v: %w", msg.Uid, msg.Part, err) return err } @@ -534,12 +534,12 @@ func (w *Worker) handleFetchFullMessages(msg *types.FetchFullMessages) error { for _, uid := range msg.Uids { m, err := w.c.Message(*w.selected, uid) if err != nil { - logging.Errorf("could not get message %d: %v", uid, err) + logging.Errorf("could not get message %d: %w", uid, err) return err } r, err := m.NewReader() if err != nil { - logging.Errorf("could not get message reader: %v", err) + logging.Errorf("could not get message reader: %w", err) return err } defer r.Close() @@ -570,7 +570,7 @@ func (w *Worker) handleDeleteMessages(msg *types.DeleteMessages) error { }, nil) } if err != nil { - logging.Errorf("failed removing messages: %v", err) + logging.Errorf("failed removing messages: %w", err) return err } return nil @@ -580,18 +580,18 @@ func (w *Worker) handleAnsweredMessages(msg *types.AnsweredMessages) error { for _, uid := range msg.Uids { m, err := w.c.Message(*w.selected, uid) if err != nil { - logging.Errorf("could not get message: %v", err) + logging.Errorf("could not get message: %w", err) w.err(msg, err) continue } if err := m.MarkReplied(msg.Answered); err != nil { - logging.Errorf("could not mark message as answered: %v", err) + logging.Errorf("could not mark message as answered: %w", err) w.err(msg, err) continue } info, err := m.MessageInfo() if err != nil { - logging.Errorf("could not get message info: %v", err) + logging.Errorf("could not get message info: %w", err) w.err(msg, err) continue } @@ -612,19 +612,19 @@ func (w *Worker) handleFlagMessages(msg *types.FlagMessages) error { for _, uid := range msg.Uids { m, err := w.c.Message(*w.selected, uid) if err != nil { - logging.Errorf("could not get message: %v", err) + logging.Errorf("could not get message: %w", err) w.err(msg, err) continue } flag := flagToMaildir[msg.Flag] if err := m.SetOneFlag(flag, msg.Enable); err != nil { - logging.Errorf("could change flag %v to %v on message: %v", flag, msg.Enable, err) + logging.Errorf("could change flag %v to %v on message: %w", flag, msg.Enable, err) w.err(msg, err) continue } info, err := m.MessageInfo() if err != nil { - logging.Errorf("could not get message info: %v", err) + logging.Errorf("could not get message info: %w", err) w.err(msg, err) continue } @@ -661,12 +661,12 @@ func (w *Worker) handleAppendMessage(msg *types.AppendMessage) error { dest := w.c.Dir(msg.Destination) _, writer, err := dest.Create(translateFlags(msg.Flags)) if err != nil { - logging.Errorf("could not create message at %s: %v", msg.Destination, err) + logging.Errorf("could not create message at %s: %w", msg.Destination, err) return err } defer writer.Close() if _, err := io.Copy(writer, msg.Reader); err != nil { - logging.Errorf("could not write message to destination: %v", err) + logging.Errorf("could not write message to destination: %w", err) return err } w.worker.PostMessage(&types.Done{ @@ -729,7 +729,7 @@ func (w *Worker) handleCheckMail(msg *types.CheckMail) { w.err(msg, fmt.Errorf("checkmail: timed out")) case err := <-ch: if err != nil { - w.err(msg, fmt.Errorf("checkmail: error running command: %v", err)) + w.err(msg, fmt.Errorf("checkmail: error running command: %w", err)) } else { w.done(msg) } diff --git a/worker/mbox/io.go b/worker/mbox/io.go index 3846916..6729048 100644 --- a/worker/mbox/io.go +++ b/worker/mbox/io.go @@ -1,6 +1,7 @@ package mboxer import ( + "errors" "io" "io/ioutil" "time" @@ -16,7 +17,7 @@ func Read(r io.Reader) ([]lib.RawMessage, error) { messages := make([]lib.RawMessage, 0) for { msg, err := mbr.NextMessage() - if err == io.EOF { + if errors.Is(err, io.EOF) { break } else if err != nil { return nil, err diff --git a/worker/mbox/models.go b/worker/mbox/models.go index d98b14f..849133c 100644 --- a/worker/mbox/models.go +++ b/worker/mbox/models.go @@ -89,7 +89,7 @@ func (md *mailboxContainer) Copy(dest, src string, uids []uint32) error { } err = destmbox.Append(r, flags) if err != nil { - return fmt.Errorf("could not append data to mbox: %v", err) + return fmt.Errorf("could not append data to mbox: %w", err) } } } diff --git a/worker/mbox/worker.go b/worker/mbox/worker.go index 6114870..1e3ab98 100644 --- a/worker/mbox/worker.go +++ b/worker/mbox/worker.go @@ -2,6 +2,7 @@ package mboxer import ( "bytes" + "errors" "fmt" "io/ioutil" "net/url" @@ -113,12 +114,12 @@ func (w *mboxWorker) handleMessage(msg types.WorkerMessage) error { for _, uid := range w.folder.Uids() { m, err := w.folder.Message(uid) if err != nil { - logging.Errorf("could not get message %v", err) + logging.Errorf("could not get message %w", err) continue } info, err := lib.MessageInfo(m) if err != nil { - logging.Errorf("could not get message info %v", err) + logging.Errorf("could not get message info %w", err) continue } infos = append(infos, info) @@ -176,27 +177,27 @@ func (w *mboxWorker) handleMessage(msg types.WorkerMessage) error { case *types.FetchMessageBodyPart: m, err := w.folder.Message(msg.Uid) if err != nil { - logging.Errorf("could not get message %d: %v", msg.Uid, err) + logging.Errorf("could not get message %d: %w", msg.Uid, err) reterr = err break } contentReader, err := m.NewReader() if err != nil { - reterr = fmt.Errorf("could not get message reader: %v", err) + reterr = fmt.Errorf("could not get message reader: %w", err) break } fullMsg, err := gomessage.Read(contentReader) if err != nil { - reterr = fmt.Errorf("could not read message: %v", err) + reterr = fmt.Errorf("could not read message: %w", err) break } r, err := lib.FetchEntityPartReader(fullMsg, msg.Part) if err != nil { logging.Errorf( - "could not get body part reader for message=%d, parts=%#v: %v", + "could not get body part reader for message=%d, parts=%#v: %w", msg.Uid, msg.Part, err) reterr = err break @@ -214,18 +215,18 @@ func (w *mboxWorker) handleMessage(msg types.WorkerMessage) error { for _, uid := range msg.Uids { m, err := w.folder.Message(uid) if err != nil { - logging.Errorf("could not get message for uid %d: %v", uid, err) + logging.Errorf("could not get message for uid %d: %w", uid, err) continue } r, err := m.NewReader() if err != nil { - logging.Errorf("could not get message reader: %v", err) + logging.Errorf("could not get message reader: %w", err) continue } defer r.Close() b, err := ioutil.ReadAll(r) if err != nil { - logging.Errorf("could not get message reader: %v", err) + logging.Errorf("could not get message reader: %w", err) continue } w.worker.PostMessage(&types.FullMessage{ @@ -260,16 +261,16 @@ func (w *mboxWorker) handleMessage(msg types.WorkerMessage) error { for _, uid := range msg.Uids { m, err := w.folder.Message(uid) if err != nil { - logging.Errorf("could not get message: %v", err) + logging.Errorf("could not get message: %w", err) continue } if err := m.(*message).SetFlag(msg.Flag, msg.Enable); err != nil { - logging.Errorf("could change flag %v to %t on message: %v", msg.Flag, msg.Enable, err) + logging.Errorf("could change flag %v to %t on message: %w", msg.Flag, msg.Enable, err) continue } info, err := lib.MessageInfo(m) if err != nil { - logging.Errorf("could not get message info: %v", err) + logging.Errorf("could not get message info: %w", err) continue } @@ -365,7 +366,7 @@ func (w *mboxWorker) handleMessage(msg types.WorkerMessage) error { func (w *mboxWorker) Run() { for msg := range w.worker.Actions { msg = w.worker.ProcessAction(msg) - if err := w.handleMessage(msg); err == errUnsupported { + if err := w.handleMessage(msg); errors.Is(err, errUnsupported) { w.worker.PostMessage(&types.Unsupported{ Message: types.RespondTo(msg), }, nil) diff --git a/worker/notmuch/lib/database.go b/worker/notmuch/lib/database.go index e8a581c..007a0a7 100644 --- a/worker/notmuch/lib/database.go +++ b/worker/notmuch/lib/database.go @@ -4,6 +4,7 @@ package lib import ( + "errors" "fmt" "time" @@ -55,7 +56,7 @@ func (db *DB) connect(writable bool) error { var err error db.db, err = notmuch.Open(db.path, mode) if err != nil { - return fmt.Errorf("could not connect to notmuch db: %v", err) + return fmt.Errorf("could not connect to notmuch db: %w", err) } db.lastOpenTime = time.Now() return nil @@ -112,7 +113,7 @@ func (db *DB) newQuery(ndb *notmuch.DB, query string) (*notmuch.Query, error) { q.SetSortScheme(notmuch.SORT_OLDEST_FIRST) for _, t := range db.excludedTags { err := q.AddTagExclude(t) - if err != nil && err != notmuch.ErrIgnored { + if errors.Is(err, notmuch.ErrIgnored) { return nil, err } } diff --git a/worker/notmuch/message.go b/worker/notmuch/message.go index fe82700..a51f78b 100644 --- a/worker/notmuch/message.go +++ b/worker/notmuch/message.go @@ -49,7 +49,7 @@ func (m *Message) NewBodyPartReader(requestedParts []int) (io.Reader, error) { defer f.Close() msg, err := message.Read(f) if err != nil { - return nil, fmt.Errorf("could not read message: %v", err) + return nil, fmt.Errorf("could not read message: %w", err) } return lib.FetchEntityPartReader(msg, requestedParts) } diff --git a/worker/notmuch/worker.go b/worker/notmuch/worker.go index dba7857..e6a9a49 100644 --- a/worker/notmuch/worker.go +++ b/worker/notmuch/worker.go @@ -7,6 +7,7 @@ import ( "bufio" "bytes" "context" + "errors" "fmt" "io/ioutil" "net/url" @@ -61,22 +62,22 @@ func (w *worker) Run() { select { case action := <-w.w.Actions: msg := w.w.ProcessAction(action) - if err := w.handleMessage(msg); err == errUnsupported { + if err := w.handleMessage(msg); errors.Is(err, errUnsupported) { w.w.PostMessage(&types.Unsupported{ Message: types.RespondTo(msg), }, nil) - logging.Errorf("ProcessAction(%T) unsupported: %v", msg, err) + logging.Errorf("ProcessAction(%T) unsupported: %w", msg, err) } else if err != nil { w.w.PostMessage(&types.Error{ Message: types.RespondTo(msg), Error: err, }, nil) - logging.Errorf("ProcessAction(%T) failure: %v", msg, err) + logging.Errorf("ProcessAction(%T) failure: %w", msg, err) } case nmEvent := <-w.nmEvents: err := w.handleNotmuchEvent(nmEvent) if err != nil { - logging.Errorf("notmuch event failure: %v", err) + logging.Errorf("notmuch event failure: %w", err) } } } @@ -157,22 +158,22 @@ func (w *worker) handleConfigure(msg *types.Configure) error { w.setupErr = nil return } - w.setupErr = fmt.Errorf("notmuch: %v", err) + w.setupErr = fmt.Errorf("notmuch: %w", err) }() u, err := url.Parse(msg.Config.Source) if err != nil { - logging.Errorf("error configuring notmuch worker: %v", err) + logging.Errorf("error configuring notmuch worker: %w", err) return err } home, err := homedir.Expand(u.Hostname()) if err != nil { - return fmt.Errorf("could not resolve home directory: %v", err) + return fmt.Errorf("could not resolve home directory: %w", err) } pathToDB := filepath.Join(home, u.Path) err = w.loadQueryMap(msg.Config) if err != nil { - return fmt.Errorf("could not load query map configuration: %v", err) + return fmt.Errorf("could not load query map configuration: %w", err) } excludedTags := w.loadExcludeTags(msg.Config) w.db = notmuch.NewDB(pathToDB, excludedTags) @@ -313,13 +314,13 @@ func (w *worker) handleFetchMessageHeaders( for _, uid := range msg.Uids { m, err := w.msgFromUid(uid) if err != nil { - logging.Errorf("could not get message: %v", err) + logging.Errorf("could not get message: %w", err) w.err(msg, err) continue } err = w.emitMessageInfo(m, msg) if err != nil { - logging.Errorf("could not emit message info: %v", err) + logging.Errorf("could not emit message info: %w", err) w.err(msg, err) continue } @@ -360,13 +361,13 @@ func (w *worker) handleFetchMessageBodyPart( ) error { m, err := w.msgFromUid(msg.Uid) if err != nil { - logging.Errorf("could not get message %d: %v", msg.Uid, err) + logging.Errorf("could not get message %d: %w", msg.Uid, err) return err } r, err := m.NewBodyPartReader(msg.Part) if err != nil { logging.Errorf( - "could not get body part reader for message=%d, parts=%#v: %v", + "could not get body part reader for message=%d, parts=%#v: %w", msg.Uid, msg.Part, err) return err } @@ -386,12 +387,12 @@ func (w *worker) handleFetchFullMessages(msg *types.FetchFullMessages) error { for _, uid := range msg.Uids { m, err := w.msgFromUid(uid) if err != nil { - logging.Errorf("could not get message %d: %v", uid, err) + logging.Errorf("could not get message %d: %w", uid, err) return err } r, err := m.NewReader() if err != nil { - logging.Errorf("could not get message reader: %v", err) + logging.Errorf("could not get message reader: %w", err) return err } defer r.Close() @@ -415,24 +416,24 @@ func (w *worker) handleAnsweredMessages(msg *types.AnsweredMessages) error { for _, uid := range msg.Uids { m, err := w.msgFromUid(uid) if err != nil { - logging.Errorf("could not get message: %v", err) + logging.Errorf("could not get message: %w", err) w.err(msg, err) continue } if err := m.MarkAnswered(msg.Answered); err != nil { - logging.Errorf("could not mark message as answered: %v", err) + logging.Errorf("could not mark message as answered: %w", err) w.err(msg, err) continue } err = w.emitMessageInfo(m, msg) if err != nil { - logging.Errorf("could not emit message info: %v", err) + logging.Errorf("could not emit message info: %w", err) w.err(msg, err) continue } } if err := w.emitDirectoryInfo(w.currentQueryName); err != nil { - logging.Errorf("could not emit directory info: %v", err) + logging.Errorf("could not emit directory info: %w", err) } w.done(msg) return nil @@ -442,24 +443,24 @@ func (w *worker) handleFlagMessages(msg *types.FlagMessages) error { for _, uid := range msg.Uids { m, err := w.msgFromUid(uid) if err != nil { - logging.Errorf("could not get message: %v", err) + logging.Errorf("could not get message: %w", err) w.err(msg, err) continue } if err := m.SetFlag(msg.Flag, msg.Enable); err != nil { - logging.Errorf("could not set flag %v as %t for message: %v", msg.Flag, msg.Enable, err) + logging.Errorf("could not set flag %v as %t for message: %w", msg.Flag, msg.Enable, err) w.err(msg, err) continue } err = w.emitMessageInfo(m, msg) if err != nil { - logging.Errorf("could not emit message info: %v", err) + logging.Errorf("could not emit message info: %w", err) w.err(msg, err) continue } } if err := w.emitDirectoryInfo(w.currentQueryName); err != nil { - logging.Errorf("could not emit directory info: %v", err) + logging.Errorf("could not emit directory info: %w", err) } w.done(msg) return nil @@ -488,11 +489,11 @@ func (w *worker) handleModifyLabels(msg *types.ModifyLabels) error { for _, uid := range msg.Uids { m, err := w.msgFromUid(uid) if err != nil { - return fmt.Errorf("could not get message from uid %d: %v", uid, err) + return fmt.Errorf("could not get message from uid %d: %w", uid, err) } err = m.ModifyTags(msg.Add, msg.Remove) if err != nil { - return fmt.Errorf("could not modify message tags: %v", err) + return fmt.Errorf("could not modify message tags: %w", err) } err = w.emitMessageInfo(m, msg) if err != nil { @@ -508,7 +509,7 @@ func (w *worker) handleModifyLabels(msg *types.ModifyLabels) error { // and update the list of possible tags w.emitLabelList() if err = w.emitDirectoryInfo(w.currentQueryName); err != nil { - logging.Errorf("could not emit directory info: %v", err) + logging.Errorf("could not emit directory info: %w", err) } w.done(msg) return nil @@ -572,11 +573,11 @@ func (w *worker) emitDirectoryContents(parent types.WorkerMessage) error { } uids, err := w.uidsFromQuery(query) if err != nil { - return fmt.Errorf("could not fetch uids: %v", err) + return fmt.Errorf("could not fetch uids: %w", err) } sortedUids, err := w.sort(uids, w.currentSortCriteria) if err != nil { - logging.Errorf("error sorting directory: %v", err) + logging.Errorf("error sorting directory: %w", err) return err } w.w.PostMessage(&types.DirectoryContents{ @@ -609,7 +610,7 @@ func (w *worker) emitMessageInfo(m *Message, ) error { info, err := m.MessageInfo() if err != nil { - return fmt.Errorf("could not get MessageInfo: %v", err) + return fmt.Errorf("could not get MessageInfo: %w", err) } w.w.PostMessage(&types.MessageInfo{ Message: types.RespondTo(parent), @@ -621,7 +622,7 @@ func (w *worker) emitMessageInfo(m *Message, func (w *worker) emitLabelList() { tags, err := w.db.ListTags() if err != nil { - logging.Errorf("could not load tags: %v", err) + logging.Errorf("could not load tags: %w", err) return } w.w.PostMessage(&types.LabelList{Labels: tags}, nil) @@ -637,19 +638,19 @@ func (w *worker) sort(uids []uint32, for _, uid := range uids { m, err := w.msgFromUid(uid) if err != nil { - logging.Errorf("could not get message: %v", err) + logging.Errorf("could not get message: %w", err) continue } info, err := m.MessageInfo() if err != nil { - logging.Errorf("could not get message info: %v", err) + logging.Errorf("could not get message info: %w", err) continue } msgInfos = append(msgInfos, info) } sortedUids, err := lib.Sort(msgInfos, criteria) if err != nil { - logging.Errorf("could not sort the messages: %v", err) + logging.Errorf("could not sort the messages: %w", err) return nil, err } return sortedUids, nil @@ -673,7 +674,7 @@ func (w *worker) handleCheckMail(msg *types.CheckMail) { w.err(msg, fmt.Errorf("checkmail: timed out")) case err := <-ch: if err != nil { - w.err(msg, fmt.Errorf("checkmail: error running command: %v", err)) + w.err(msg, fmt.Errorf("checkmail: error running command: %w", err)) } else { w.done(msg) } diff --git a/worker/types/thread.go b/worker/types/thread.go index d37d206..9f59e9e 100644 --- a/worker/types/thread.go +++ b/worker/types/thread.go @@ -42,7 +42,7 @@ func (t *Thread) insertCmp(child *Thread, cmp func(*Thread, *Thread) bool) { func (t *Thread) Walk(walkFn NewThreadWalkFn) error { err := newWalk(t, walkFn, 0, nil) - if err == ErrSkipThread { + if errors.Is(err, ErrSkipThread) { return nil } return err @@ -80,7 +80,7 @@ func newWalk(node *Thread, walkFn NewThreadWalkFn, lvl int, ce error) error { } for child := node.FirstChild; child != nil; child = child.NextSibling { err = newWalk(child, walkFn, lvl+1, err) - if err == ErrSkipThread { + if errors.Is(err, ErrSkipThread) { err = nil continue } else if err != nil {