[errors] Greatly simplify common/errors package.
Now that we have tags with values, the original concept behind the 'data'
stuff in errors no longer applies. This removes the Reason().D() system and puts
the format directly into errors.Annotate. So:
errors.Annotate(err).Reason("foo: %(datum)s").D("datum", "value").Err()
Becomes:
errors.Annotate(err, "foo %s", "value").Err()
This also removes a bunch of rarely-or-never-used symbols from common/errors by
making them internal (particularly w.r.t. rendering an error). If we ever develop
a need for them, it would be easy to bring them back.
R=dnj@chromium.org, vadimsh@chromium.org
BUG=
Review-Url: https://codereview.chromium.org/2963503003 .
diff --git a/appengine/datastorecache/manager.go b/appengine/datastorecache/manager.go
index da801bd..4beac6b 100644
--- a/appengine/datastorecache/manager.go
+++ b/appengine/datastorecache/manager.go
@@ -5,7 +5,6 @@
package datastorecache
import (
- "bytes"
"fmt"
"net/http"
"strings"
@@ -41,17 +40,15 @@
// maximum log message size with a full stack.
stk := errors.RenderStack(err)
log.WithError(err).Errorf(ctx.Context, "Handler returned error.")
- for _, line := range stk.ToLines() {
+ for _, line := range stk {
log.Errorf(ctx.Context, ">> %s", line)
}
dumpErr := func() error {
- var buf bytes.Buffer
- if _, err := stk.DumpTo(&buf); err != nil {
- return err
- }
- if _, err := buf.WriteTo(ctx.Writer); err != nil {
- return err
+ for _, line := range stk {
+ if _, err := ctx.Writer.Write([]byte(line + "\n")); err != nil {
+ return err
+ }
}
return nil
}()
@@ -148,12 +145,12 @@
}()
if err := ms.runLocked(c); err != nil {
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "running maintenance loop").Err()
}
// If we observed errors during processing, note this.
if ms.errors > 0 {
- return errors.Reason("%(count)d error(s) encountered during processing").D("count", ms.errors).Err()
+ return errors.Reason("%d error(s) encountered during processing", ms.errors).Err()
}
return nil
})
@@ -330,7 +327,7 @@
return nil
})
if err != nil {
- return errors.Annotate(err).Reason("failed to run entry query").Err()
+ return errors.Annotate(err, "failed to run entry query").Err()
}
// Flush any outstanding entries (ignore error, will always be nil).
diff --git a/appengine/gaeauth/server/oauth.go b/appengine/gaeauth/server/oauth.go
index 58c4697..1b267e7 100644
--- a/appengine/gaeauth/server/oauth.go
+++ b/appengine/gaeauth/server/oauth.go
@@ -110,7 +110,7 @@
if err == googleoauth.ErrBadToken {
return nil, err
}
- return nil, errors.Annotate(err).Reason("oauth: transient error when validating token").
+ return nil, errors.Annotate(err, "oauth: transient error when validating token").
Tag(transient.Tag).Err()
}
diff --git a/cipd/client/cipd/ensure/file.go b/cipd/client/cipd/ensure/file.go
index 1328c14..65775cc 100644
--- a/cipd/client/cipd/ensure/file.go
+++ b/cipd/client/cipd/ensure/file.go
@@ -137,7 +137,7 @@
if f.ServiceURL != "" {
// double check the url
if _, err := url.Parse(f.ServiceURL); err != nil {
- return nil, errors.Annotate(err).Reason("bad ServiceURL").Err()
+ return nil, errors.Annotate(err, "bad ServiceURL").Err()
}
}
@@ -153,10 +153,7 @@
for subdir, pkgs := range f.PackagesBySubdir {
// double-check the subdir
if err := common.ValidateSubdir(subdir); err != nil {
- return nil, errors.Annotate(err).
- Reason("normalizing %(subdir)q").
- D("subdir", subdir).
- Err()
+ return nil, errors.Annotate(err, "normalizing %q", subdir).Err()
}
for _, pkg := range pkgs {
pin, err := pkg.Resolve(rslv, templateArgs)
@@ -164,17 +161,13 @@
continue
}
if err != nil {
- return nil, errors.Annotate(err).Reason("resolving package").Err()
+ return nil, errors.Annotate(err, "resolving package").Err()
}
if origLineNo, ok := resolvedPkgDupList[subdir][pin.PackageName]; ok {
return nil, errors.
- Reason("duplicate package in subdir %(subdir)q: %(pkg)q: defined on line %(orig)d and %(new)d").
- D("subdir", subdir).
- D("pkg", pin.PackageName).
- D("orig", origLineNo).
- D("new", pkg.LineNo).
- Err()
+ Reason("duplicate package in subdir %q: %q: defined on line %d and %d",
+ subdir, pin.PackageName, origLineNo, pkg.LineNo).Err()
}
if resolvedPkgDupList[subdir] == nil {
resolvedPkgDupList[subdir] = map[string]int{}
diff --git a/cipd/client/cipd/ensure/package_def.go b/cipd/client/cipd/ensure/package_def.go
index 1efe662..798e01d 100644
--- a/cipd/client/cipd/ensure/package_def.go
+++ b/cipd/client/cipd/ensure/package_def.go
@@ -47,19 +47,13 @@
return
}
if err != nil {
- err = errors.Annotate(err).
- Reason("failed to resolve package template (line %(line)d)").
- D("line", p.LineNo).
- Err()
+ err = errors.Annotate(err, "failed to resolve package template (line %d)", p.LineNo).Err()
return
}
pin, err = rslv(pin.PackageName, p.UnresolvedVersion)
if err != nil {
- err = errors.Annotate(err).
- Reason("failed to resolve package version (line %(line)d)").
- D("line", p.LineNo).
- Err()
+ err = errors.Annotate(err, "failed to resolve package version (line %d)", p.LineNo).Err()
return
}
diff --git a/cipd/client/cipd/ensure/template.go b/cipd/client/cipd/ensure/template.go
index 4934297..199179c 100644
--- a/cipd/client/cipd/ensure/template.go
+++ b/cipd/client/cipd/ensure/template.go
@@ -34,14 +34,13 @@
return value
}
- err = errors.Reason("unknown variable in ${%(contents)s}").
- D("contents", contents).Err()
+ err = errors.Reason("unknown variable in ${%s}", contents).Err()
}
// ${varName=value,value}
ourValue, ok := expansionLookup[varNameValues[0]]
if !ok {
- err = errors.Reason("unknown variable %(parm)q").D("parm", parm).Err()
+ err = errors.Reason("unknown variable %q", parm).Err()
return parm
}
@@ -57,8 +56,7 @@
err = errSkipTemplate
}
if err == nil && strings.ContainsRune(pkg, '$') {
- err = errors.Reason("unable to process some variables in %(template)q").
- D("template", template).Err()
+ err = errors.Reason("unable to process some variables in %q", template).Err()
}
if err == nil {
err = common.ValidatePackageName(pkg)
diff --git a/client/isolate/utils.go b/client/isolate/utils.go
index b66ab49..83fa8f7 100644
--- a/client/isolate/utils.go
+++ b/client/isolate/utils.go
@@ -5,7 +5,6 @@
package isolate
import (
- "fmt"
"log"
"path"
"runtime"
@@ -20,7 +19,7 @@
if err == nil {
return
}
- log.Panic(errors.RenderStack(fmt.Errorf("assertion failed due to error: %s", err)).ToLines())
+ log.Panic(errors.RenderStack(errors.Annotate(err, "assertion failed").Err()))
}
func assert(condition bool, info ...interface{}) {
@@ -28,9 +27,9 @@
return
}
if len(info) == 0 {
- log.Panic(errors.RenderStack(errors.New("assertion failed")).ToLines())
+ log.Panic(errors.RenderStack(errors.New("assertion failed")))
} else if format, ok := info[0].(string); ok {
- log.Panic(errors.RenderStack(fmt.Errorf("assertion failed: "+format, info[1:]...)).ToLines())
+ log.Panic(errors.RenderStack(errors.Reason("assertion failed: "+format, info[1:]...).Err()))
}
}
diff --git a/common/config/impl/filesystem/fs.go b/common/config/impl/filesystem/fs.go
index 4bcf6cd..e23ac80 100644
--- a/common/config/impl/filesystem/fs.go
+++ b/common/config/impl/filesystem/fs.go
@@ -185,16 +185,13 @@
return nil, err
}
if !inf.IsDir() {
- return nil, (errors.Reason("filesystem.New(%(basePath)q): does not link to a directory").
- D("basePath", basePath).Err())
+ return nil, errors.Reason("filesystem.New(%q): does not link to a directory", basePath).Err()
}
if len(ret.basePath.explode()) < 1 {
- return nil, (errors.Reason("filesystem.New(%(basePath)q): not enough tokens in path").
- D("basePath", basePath).Err())
+ return nil, errors.Reason("filesystem.New(%q): not enough tokens in path", basePath).Err()
}
} else if !inf.IsDir() {
- return nil, (errors.Reason("filesystem.New(%(basePath)q): not a directory").
- D("basePath", basePath).Err())
+ return nil, errors.Reason("filesystem.New(%q): not a directory", basePath).Err()
}
return ret, nil
}
diff --git a/common/config/impl/filesystem/paths.go b/common/config/impl/filesystem/paths.go
index 78fe6ee..745e8bc 100644
--- a/common/config/impl/filesystem/paths.go
+++ b/common/config/impl/filesystem/paths.go
@@ -57,7 +57,7 @@
func (c configSet) validate() error {
if !c.hasPrefix("projects/") && !c.hasPrefix("services/") {
- return errors.Reason("configSet.validate: bad prefix %(cs)q").D("cs", c.s()).Err()
+ return errors.Reason("configSet.validate: bad prefix %q", c.s()).Err()
}
return nil
}
diff --git a/common/config/validation/validation.go b/common/config/validation/validation.go
index 6263fec..ace7138 100644
--- a/common/config/validation/validation.go
+++ b/common/config/validation/validation.go
@@ -46,7 +46,9 @@
type fileTagType struct{ Key errors.TagKey }
-func (f fileTagType) With(name string) errors.TagValue { return errors.MkTagValue(f.Key, name) }
+func (f fileTagType) With(name string) errors.TagValue {
+ return errors.TagValue{Key: f.Key, Value: name}
+}
func (f fileTagType) In(err error) (v string, ok bool) {
d, ok := errors.TagValueIn(f.Key, err)
if ok {
@@ -58,7 +60,7 @@
type elementTagType struct{ Key errors.TagKey }
func (e elementTagType) With(elements []string) errors.TagValue {
- return errors.MkTagValue(e.Key, append([]string(nil), elements...))
+ return errors.TagValue{Key: e.Key, Value: append([]string(nil), elements...)}
}
func (e elementTagType) In(err error) (v []string, ok bool) {
d, ok := errors.TagValueIn(e.Key, err)
diff --git a/common/data/text/stringtemplate/template.go b/common/data/text/stringtemplate/template.go
index 1140c2d..007f174 100644
--- a/common/data/text/stringtemplate/template.go
+++ b/common/data/text/stringtemplate/template.go
@@ -60,9 +60,7 @@
switch {
case match[8] >= 0:
// Invalid.
- return "", errors.Reason("invalid template: %(template)q").
- D("template", v).
- Err()
+ return "", errors.Reason("invalid template: %q", v).Err()
case match[2] >= 0:
// Escaped.
@@ -90,9 +88,7 @@
subst, ok := subst[key]
if !ok {
- return "", errors.Reason("no substitution for %(key)q").
- D("key", key).
- Err()
+ return "", errors.Reason("no substitution for %q", key).Err()
}
parts = append(parts, subst)
}
diff --git a/common/errors/annotate.go b/common/errors/annotate.go
index 91dab74..4a0964a 100644
--- a/common/errors/annotate.go
+++ b/common/errors/annotate.go
@@ -10,7 +10,6 @@
"fmt"
"io"
"path/filepath"
- "regexp"
"runtime"
"sort"
"strings"
@@ -24,20 +23,6 @@
"github.com/luci/luci-go/common/runtime/goroutine"
)
-// Datum is a single data entry value for stackContext.Data.
-//
-// It's a tuple of Value (the actual data value you care about), and
-// StackFormat, which is a fmt-style string for how this Datum should be
-// rendered when using RenderStack. If StackFormat is left empty, "%#v" will be
-// used.
-type Datum struct {
- Value interface{}
- StackFormat string
-}
-
-// Data is used to add data when Annotate'ing an error.
-type Data map[string]Datum
-
type stack struct {
id goroutine.ID
frames []uintptr
@@ -85,87 +70,34 @@
// annotation of an error.
type stackContext struct {
frameInfo stackFrameInfo
- // reason is the publicly-facing reason, and will show up in the Error()
- // string.
+ // publicly-facing reason, and will show up in the Error() string.
reason string
- // InternalReason is used for printing tracebacks, but is otherwise formatted
- // like reason.
+ // used for printing tracebacks, but will not show up in the Error() string.
internalReason string
- data Data
+ // tags are any data associated with this frame.
tags map[TagKey]interface{}
}
-// We're looking for %(sometext) which is not preceded by a %. sometext may be
-// any characters except for a close paren.
-//
-// Submatch indices:
-// [0:1] Full match
-// [2:3] Text before the (...) pair (including the '%').
-// [4:5] (key)
-var namedFormatMatcher = regexp.MustCompile(`((?:^|[^%])%)\(([^)]+)\)`)
-
-// Format uses the data contained in this Data map to format the provided
-// string. Items from the map are looked up in python dict-format style, e.g.
-//
-// %(key)d
-//
-// Will look up the item "key", and then format as a decimal number it using the
-// value for "key" in this Data map. Like python, a given item may appear
-// multiple times in the format string.
-//
-// All formatting directives are identical to the ones used by fmt.Sprintf.
-func (d Data) Format(format string) string {
- smi := namedFormatMatcher.FindAllStringSubmatchIndex(format, -1)
-
- var (
- parts = make([]string, 0, len(smi)+1)
- args = make([]interface{}, 0, len(smi))
- pos = 0
- )
- for _, match := range smi {
- // %(key)s => %s
- parts = append(parts, format[pos:match[3]])
- pos = match[1]
-
- // Add key to args.
- key := format[match[4]:match[5]]
- if v, ok := d[key]; ok {
- args = append(args, v.Value)
- } else {
- args = append(args, fmt.Sprintf("MISSING(key=%q)", key))
- }
- }
- parts = append(parts, format[pos:])
- return fmt.Sprintf(strings.Join(parts, ""), args...)
-}
-
// renderPublic renders the public error.Error()-style string for this frame,
-// using the Reason and Data to produce a human readable string.
+// combining this frame's Reason with the inner error.
func (s *stackContext) renderPublic(inner error) string {
- if s.reason == "" {
- if inner != nil {
- return inner.Error()
- }
- return ""
+ switch {
+ case inner == nil:
+ return s.reason
+ case s.reason == "":
+ return inner.Error()
}
-
- basis := s.data.Format(s.reason)
- if inner != nil {
- return fmt.Sprintf("%s: %s", basis, inner)
- }
- return basis
+ return fmt.Sprintf("%s: %s", s.reason, inner.Error())
}
// render renders the frame as a single entry in a stack trace. This looks like:
//
-// I am an internal reson formatted with key1: value
// reason: "The literal content of the reason field: %(key2)d"
-// "key1" = "value"
-// "key2" = 10
-func (s *stackContext) render() Lines {
- siz := len(s.data)
+// internal reason: I am an internal reason formatted with key1: value
+func (s *stackContext) render() lines {
+ siz := len(s.tags)
if s.internalReason != "" {
siz++
}
@@ -176,51 +108,25 @@
return nil
}
- ret := make(Lines, 0, siz)
-
- if s.internalReason != "" {
- ret = append(ret, s.data.Format(s.internalReason))
- }
+ ret := make(lines, 0, siz)
if s.reason != "" {
- ret = append(ret, fmt.Sprintf("reason: %q", s.data.Format(s.reason)))
+ ret = append(ret, fmt.Sprintf("reason: %s", s.reason))
}
- for key, val := range s.tags {
- ret = append(ret, fmt.Sprintf("tag[%q]: %#v", key.description, val))
+ if s.internalReason != "" {
+ ret = append(ret, fmt.Sprintf("internal reason: %s", s.internalReason))
}
-
- if len(s.data) > 0 {
- for k, v := range s.data {
- if v.StackFormat == "" || v.StackFormat == "%#v" {
- ret = append(ret, fmt.Sprintf("%q = %#v", k, v.Value))
- } else {
- ret = append(ret, fmt.Sprintf("%q = "+v.StackFormat, k, v.Value))
- }
- }
- sort.Strings(ret[len(ret)-len(s.data):])
+ keys := make(tagKeySlice, 0, len(s.tags))
+ for key := range s.tags {
+ keys = append(keys, key)
+ }
+ sort.Sort(keys)
+ for _, key := range keys {
+ ret = append(ret, fmt.Sprintf("tag[%q]: %#v", key.description, s.tags[key]))
}
return ret
}
-// addData does a 'dict.update' addition of the data.
-func (s *stackContext) addData(data Data) {
- if s.data == nil {
- s.data = make(Data, len(data))
- }
- for k, v := range data {
- s.data[k] = v
- }
-}
-
-// addDatum adds a single data item to the Data in this frame
-func (s *stackContext) addDatum(key string, value interface{}, format string) {
- if s.data == nil {
- s.data = Data{key: {value, format}}
- } else {
- s.data[key] = Datum{value, format}
- }
-}
-
type terminalStackError struct {
error
finfo stackFrameInfo
@@ -260,65 +166,20 @@
ctx stackContext
}
-// Reason adds a PUBLICLY READABLE reason string (for humans) to this error.
-//
-// You should assume that end-users (including unauthenticated end users) may
-// see the text in here.
-//
-// These reasons will be used to compose the result of the final Error() when
-// rendering this error, and will also be used to decorate the error
-// annotation stack when logging the error using the Log function.
-//
-// In a webserver context, if you don't want users to see some information about
-// this error, don't put it in the Reason.
-//
-// This explanation may have formatting instructions in the form of:
-// %(key)...
-// where key is the name of one of the entries submitted to either D or Data.
-// The `...` may be any Printf-compatible formatting directive.
-func (a *Annotator) Reason(reason string) *Annotator {
- if a == nil {
- return a
- }
- a.ctx.reason = reason
- return a
-}
-
// InternalReason adds a stack-trace-only internal reason string (for humans) to
-// this error. This is formatted like Reason, but will not be visible in the
-// Error() string.
-func (a *Annotator) InternalReason(reason string) *Annotator {
+// this error.
+//
+// The text here will only be visible when using `errors.Log` or
+// `errors.RenderStack`, not when calling the .Error() method of the resulting
+// error.
+//
+// The `reason` string is formatted with `args` and may contain Sprintf-style
+// formatting directives.
+func (a *Annotator) InternalReason(reason string, args ...interface{}) *Annotator {
if a == nil {
return a
}
- a.ctx.internalReason = reason
- return a
-}
-
-// D adds a single datum to this error. Only one format may be specified. If
-// format is omitted or the empty string, the format "%#v" will be used.
-func (a *Annotator) D(key string, value interface{}, format ...string) *Annotator {
- if a == nil {
- return a
- }
- formatVal := ""
- switch len(format) {
- case 0:
- case 1:
- formatVal = format[0]
- default:
- panic(fmt.Errorf("len(format) > 1: %d", len(format)))
- }
- a.ctx.addDatum(key, value, formatVal)
- return a
-}
-
-// Data adds data to this error.
-func (a *Annotator) Data(data Data) *Annotator {
- if a == nil {
- return a
- }
- a.ctx.addData(data)
+ a.ctx.internalReason = fmt.Sprintf(reason, args...)
return a
}
@@ -357,43 +218,45 @@
// Log logs the full error. If this is an Annotated error, it will log the full
// stack information as well.
-func Log(c context.Context, err error) {
+//
+// This is a shortcut for logging the output of RenderStack(err).
+func Log(c context.Context, err error, excludePkgs ...string) {
log := logging.Get(c)
- for _, l := range RenderStack(err).ToLines() {
+ for _, l := range RenderStack(err, excludePkgs...) {
log.Errorf("%s", l)
}
}
-// Lines is just a list of printable lines.
+// lines is just a list of printable lines.
//
-// It's a type because it's most frequently used as []Lines, and [][]string
+// It's a type because it's most frequently used as []lines, and [][]string
// doesn't read well.
-type Lines []string
+type lines []string
-// RenderedFrame represents a single, rendered stack frame.
-type RenderedFrame struct {
- Pkg string
- File string
- LineNum int
- FuncName string
+// renderedFrame represents a single, rendered stack frame.
+type renderedFrame struct {
+ pkg string
+ file string
+ lineNum int
+ funcName string
- // Wrappers is any frame-info-less errors.Wrapped that were encountered when
+ // wrappers is any frame-info-less errors.Wrapped that were encountered when
// rendering that didn't have any associated frame info: this is the closest
// frame to where they were added to the error.
- Wrappers []Lines
+ wrappers []lines
- // Annotations is any Annotate context associated directly with this Frame.
- Annotations []Lines
+ // annotations is any Annotate context associated directly with this Frame.
+ annotations []lines
}
var nlSlice = []byte{'\n'}
-// DumpWrappersTo formats the Wrappers portion of this RenderedFrame.
-func (r *RenderedFrame) DumpWrappersTo(w io.Writer, from, to int) (n int, err error) {
+// dumpWrappersTo formats the wrappers portion of this renderedFrame.
+func (r *renderedFrame) dumpWrappersTo(w io.Writer, from, to int) (n int, err error) {
return iotools.WriteTracker(w, func(rawWriter io.Writer) error {
w := &indented.Writer{Writer: rawWriter, UseSpaces: true}
fmt.Fprintf(w, "From frame %d to %d, the following wrappers were found:\n", from, to)
- for i, wrp := range r.Wrappers {
+ for i, wrp := range r.wrappers {
if i != 0 {
w.Write(nlSlice)
}
@@ -411,23 +274,23 @@
})
}
-// DumpTo formats the Header and Annotations for this RenderedFrame.
-func (r *RenderedFrame) DumpTo(w io.Writer, idx int) (n int, err error) {
+// dumpTo formats the Header and annotations for this renderedFrame.
+func (r *renderedFrame) dumpTo(w io.Writer, idx int) (n int, err error) {
return iotools.WriteTracker(w, func(rawWriter io.Writer) error {
w := &indented.Writer{Writer: rawWriter, UseSpaces: true}
- fmt.Fprintf(w, "#%d %s/%s:%d - %s()\n", idx, r.Pkg, r.File,
- r.LineNum, r.FuncName)
+ fmt.Fprintf(w, "#%d %s/%s:%d - %s()\n", idx, r.pkg, r.file,
+ r.lineNum, r.funcName)
w.Level += 2
- switch len(r.Annotations) {
+ switch len(r.annotations) {
case 0:
// pass
case 1:
- for _, line := range r.Annotations[0] {
+ for _, line := range r.annotations[0] {
fmt.Fprintf(w, "%s\n", line)
}
default:
- for i, ann := range r.Annotations {
+ for i, ann := range r.annotations {
fmt.Fprintf(w, "annotation #%d:\n", i)
w.Level += 2
for _, line := range ann {
@@ -440,18 +303,18 @@
})
}
-// RenderedStack is a single rendered stack from one goroutine.
-type RenderedStack struct {
- GoID goroutine.ID
- Frames []*RenderedFrame
+// renderedStack is a single rendered stack from one goroutine.
+type renderedStack struct {
+ goID goroutine.ID
+ frames []*renderedFrame
}
-// DumpTo formats the full stack.
-func (r *RenderedStack) DumpTo(w io.Writer, excludePkgs ...string) (n int, err error) {
+// dumpTo formats the full stack.
+func (r *renderedStack) dumpTo(w io.Writer, excludePkgs ...string) (n int, err error) {
excludeSet := stringset.NewFromSlice(excludePkgs...)
return iotools.WriteTracker(w, func(w io.Writer) error {
- fmt.Fprintf(w, "goroutine %d:\n", r.GoID)
+ fmt.Fprintf(w, "goroutine %d:\n", r.goID)
lastIdx := 0
needNL := false
@@ -468,31 +331,31 @@
skipPkg = ""
}
}
- for i, f := range r.Frames {
+ for i, f := range r.frames {
if needNL {
w.Write(nlSlice)
needNL = false
}
- if excludeSet.Has(f.Pkg) {
- if skipPkg == f.Pkg {
+ if excludeSet.Has(f.pkg) {
+ if skipPkg == f.pkg {
skipCount++
} else {
flushSkips("")
skipCount++
- skipPkg = f.Pkg
+ skipPkg = f.pkg
}
continue
}
flushSkips("\n")
- if len(f.Wrappers) > 0 {
- f.DumpWrappersTo(w, lastIdx, i)
+ if len(f.wrappers) > 0 {
+ f.dumpWrappersTo(w, lastIdx, i)
w.Write(nlSlice)
}
- if len(f.Annotations) > 0 {
+ if len(f.annotations) > 0 {
lastIdx = i
needNL = true
}
- f.DumpTo(w, i)
+ f.dumpTo(w, i)
}
flushSkips("")
@@ -500,38 +363,38 @@
})
}
-// RenderedError is a series of RenderedStacks, one for each goroutine that the
+// renderedError is a series of RenderedStacks, one for each goroutine that the
// error was annotated on.
-type RenderedError struct {
- OriginalError string
- Stacks []*RenderedStack
+type renderedError struct {
+ originalError string
+ stacks []*renderedStack
}
-// ToLines renders a full-information stack trace as a series of lines.
-func (r *RenderedError) ToLines(excludePkgs ...string) Lines {
+// toLines renders a full-information stack trace as a series of lines.
+func (r *renderedError) toLines(excludePkgs ...string) lines {
buf := bytes.Buffer{}
- r.DumpTo(&buf, excludePkgs...)
+ r.dumpTo(&buf, excludePkgs...)
return strings.Split(strings.TrimSuffix(buf.String(), "\n"), "\n")
}
-// DumpTo writes the full-information stack trace to the writer.
-func (r *RenderedError) DumpTo(w io.Writer, excludePkgs ...string) (n int, err error) {
+// dumpTo writes the full-information stack trace to the writer.
+func (r *renderedError) dumpTo(w io.Writer, excludePkgs ...string) (n int, err error) {
return iotools.WriteTracker(w, func(w io.Writer) error {
- if r.OriginalError != "" {
- fmt.Fprintf(w, "original error: %s\n\n", r.OriginalError)
+ if r.originalError != "" {
+ fmt.Fprintf(w, "original error: %s\n\n", r.originalError)
}
- for i := len(r.Stacks) - 1; i >= 0; i-- {
- if i != len(r.Stacks)-1 {
+ for i := len(r.stacks) - 1; i >= 0; i-- {
+ if i != len(r.stacks)-1 {
w.Write(nlSlice)
}
- r.Stacks[i].DumpTo(w, excludePkgs...)
+ r.stacks[i].dumpTo(w, excludePkgs...)
}
return nil
})
}
-func frameHeaderDetails(frm uintptr) (pkg, filename, funcname string, lineno int) {
+func frameHeaderDetails(frm uintptr) (pkg, filename, funcName string, lineno int) {
// this `frm--` is to get the correct line/function information, since the
// Frame is actually the `return` pc. See runtime.Callers.
frm--
@@ -546,45 +409,49 @@
fnName := fn.Name()
lastSlash := strings.LastIndex(fnName, "/")
if lastSlash == -1 {
- funcname = fnName
+ funcName = fnName
pkg = pkgTopLevelName
} else {
- funcname = fnName[lastSlash+1:]
+ funcName = fnName[lastSlash+1:]
pkg = fmt.Sprintf("%s/%s", fnName[:lastSlash], pkgTopLevelName)
}
return
}
-// RenderStack renders the error to a RenderedError.
-func RenderStack(err error) *RenderedError {
- ret := &RenderedError{}
+// RenderStack renders the error to a list of lines.
+func RenderStack(err error, excludePkgs ...string) []string {
+ return renderStack(err).toLines(excludePkgs...)
+}
+
+func renderStack(err error) *renderedError {
+ ret := &renderedError{}
lastAnnotatedFrame := 0
- var wrappers = []Lines{}
- getCurFrame := func(fi *stackFrameInfo) *RenderedFrame {
- if len(ret.Stacks) == 0 || ret.Stacks[len(ret.Stacks)-1].GoID != fi.forStack.id {
+ var wrappers = []lines{}
+ getCurFrame := func(fi *stackFrameInfo) *renderedFrame {
+ if len(ret.stacks) == 0 || ret.stacks[len(ret.stacks)-1].goID != fi.forStack.id {
lastAnnotatedFrame = len(fi.forStack.frames) - 1
- toAdd := &RenderedStack{
- GoID: fi.forStack.id,
- Frames: make([]*RenderedFrame, len(fi.forStack.frames)),
+ toAdd := &renderedStack{
+ goID: fi.forStack.id,
+ frames: make([]*renderedFrame, len(fi.forStack.frames)),
}
for i, frm := range fi.forStack.frames {
pkgPath, filename, functionName, line := frameHeaderDetails(frm)
- toAdd.Frames[i] = &RenderedFrame{
- Pkg: pkgPath, File: filename, LineNum: line, FuncName: functionName}
+ toAdd.frames[i] = &renderedFrame{
+ pkg: pkgPath, file: filename, lineNum: line, funcName: functionName}
}
- ret.Stacks = append(ret.Stacks, toAdd)
+ ret.stacks = append(ret.stacks, toAdd)
}
- curStack := ret.Stacks[len(ret.Stacks)-1]
+ curStack := ret.stacks[len(ret.stacks)-1]
if fi.frameIdx < lastAnnotatedFrame {
lastAnnotatedFrame = fi.frameIdx
- frm := curStack.Frames[lastAnnotatedFrame]
- frm.Wrappers = wrappers
+ frm := curStack.frames[lastAnnotatedFrame]
+ frm.wrappers = wrappers
wrappers = nil
return frm
}
- return curStack.Frames[lastAnnotatedFrame]
+ return curStack.frames[lastAnnotatedFrame]
}
for err != nil {
@@ -593,13 +460,13 @@
if stk := ctx.frameInfo.forStack; stk != nil {
frm := getCurFrame(&ctx.frameInfo)
if rendered := ctx.render(); len(rendered) > 0 {
- frm.Annotations = append(frm.Annotations, rendered)
+ frm.annotations = append(frm.annotations, rendered)
}
} else {
wrappers = append(wrappers, ctx.render())
}
} else {
- wrappers = append(wrappers, Lines{fmt.Sprintf("unknown wrapper %T", err)})
+ wrappers = append(wrappers, lines{fmt.Sprintf("unknown wrapper %T", err)})
}
switch x := err.(type) {
case MultiError:
@@ -609,7 +476,7 @@
case Wrapped:
err = x.InnerError()
default:
- ret.OriginalError = err.Error()
+ ret.originalError = err.Error()
err = nil
}
}
@@ -618,8 +485,9 @@
}
// Annotate captures the current stack frame and returns a new annotatable
-// error. You can add additional metadata to this error with its methods and
-// then get the new derived error with the Err() function.
+// error, attaching the publically readable `reason` format string to the error.
+// You can add additional metadata to this error with the 'InternalReason' and
+// 'Tag' methods, and then obtain a real `error` with the Err() function.
//
// If this is passed nil, it will return a no-op Annotator whose .Err() function
// will also return nil.
@@ -628,28 +496,42 @@
// returned error.
//
// Rendering the derived error with Error() will render a summary version of all
-// the Reasons as well as the initial underlying errors Error() text. It is
-// intended that the initial underlying error and all annotated Reasons only
-// contain user-visible information, so that the accumulated error may be
+// the public `reason`s as well as the initial underlying error's Error() text.
+// It is intended that the initial underlying error and all annotated reasons
+// only contain user-visible information, so that the accumulated error may be
// returned to the user without worrying about leakage.
-func Annotate(err error) *Annotator {
+//
+// You should assume that end-users (including unauthenticated end users) may
+// see the text in the `reason` field here. To only attach an internal reason,
+// leave the `reason` argument blank and don't pass any additional formatting
+// arguments.
+//
+// The `reason` string is formatted with `args` and may contain Sprintf-style
+// formatting directives.
+func Annotate(err error, reason string, args ...interface{}) *Annotator {
if err == nil {
return nil
}
- return &Annotator{err, stackContext{frameInfo: stackFrameInfoForError(1, err)}}
+ return &Annotator{err, stackContext{
+ frameInfo: stackFrameInfoForError(1, err),
+ reason: fmt.Sprintf(reason, args...),
+ }}
}
// Reason builds a new Annotator starting with reason. This allows you to use
// all the formatting directives you would normally use with Annotate, in case
-// your originating error needs formatting directives:
+// your originating error needs tags or an internal reason.
//
-// errors.Reason("something bad: %(value)d").D("value", 100)).Err()
+// errors.Reason("something bad: %d", value).Tag(transient.Tag).Err()
//
// Prefer this form to errors.New(fmt.Sprintf("..."))
-func Reason(reason string) *Annotator {
+func Reason(reason string, args ...interface{}) *Annotator {
currentStack := captureStack(1)
frameInfo := stackFrameInfo{0, currentStack}
- return (&Annotator{nil, stackContext{frameInfo: frameInfo}}).Reason(reason)
+ return (&Annotator{nil, stackContext{
+ frameInfo: frameInfo,
+ reason: fmt.Sprintf(reason, args...),
+ }})
}
// New is an API-compatible version of the standard errors.New function. Unlike
diff --git a/common/errors/annotate_example_test.go b/common/errors/annotate_example_test.go
index 58ee286..13b5490 100644
--- a/common/errors/annotate_example_test.go
+++ b/common/errors/annotate_example_test.go
@@ -11,11 +11,11 @@
func someProcessingFunction(val int) error {
if val == 1 {
// New and Reason automatically include stack information.
- return Reason("bad number: %(val)d").D("val", val).Err()
+ return Reason("bad number: %d", val).Err()
}
if err := someProcessingFunction(val - 1); err != nil {
// correctly handles recursion
- return Annotate(err).D("val", val).Err()
+ return Annotate(err, "").InternalReason("val(%d)", val).Err()
}
return nil
}
@@ -23,10 +23,8 @@
func someLibFunc(vals ...int) error {
for i, v := range vals {
if err := someProcessingFunction(v); err != nil {
- return (Annotate(err).Reason("processing %(val)d").
- D("val", v).
- D("i", i).
- D("secret", "value", "%s").Err())
+ return Annotate(err, "processing %d", v).
+ InternalReason("secret(%s)/i(%d)", "value", i).Err()
}
}
return nil
@@ -48,7 +46,7 @@
errch := make(chan error)
go func() {
defer close(errch)
- errch <- Annotate(errorWrapper(someLibFunc(vals...))).Reason("could not process").Err()
+ errch <- Annotate(errorWrapper(someLibFunc(vals...)), "could not process").Err()
}()
me := MultiError(nil)
for err := range errch {
@@ -57,17 +55,17 @@
}
}
if me != nil {
- return Annotate(me).Reason("while processing %(vals)v").D("vals", vals).Err()
+ return Annotate(me, "while processing %v", vals).Err()
}
return nil
}
func ExampleAnnotate() {
if err := someIntermediateFunc(3); err != nil {
- err = Annotate(err).Reason("top level").Err()
+ err = Annotate(err, "top level").Err()
fmt.Println("Public-facing error:\n ", err)
fmt.Println("\nfull error:")
- for _, l := range FixForTest(RenderStack(err).ToLines("runtime", "_test")) {
+ for _, l := range FixForTest(RenderStack(err, "runtime", "_test")) {
fmt.Println(l)
}
}
@@ -79,41 +77,35 @@
// full error:
// GOROUTINE LINE
// #? github.com/luci/luci-go/common/errors/annotate_example_test.go:14 - errors.someProcessingFunction()
- // reason: "bad number: 1"
- // "val" = 1
+ // reason: bad number: 1
//
// #? github.com/luci/luci-go/common/errors/annotate_example_test.go:16 - errors.someProcessingFunction()
- // "val" = 2
+ // internal reason: val(2)
//
// #? github.com/luci/luci-go/common/errors/annotate_example_test.go:16 - errors.someProcessingFunction()
- // "val" = 3
+ // internal reason: val(3)
//
// From frame 2 to 3, the following wrappers were found:
// unknown wrapper *errors.MiscWrappedError
//
// #? github.com/luci/luci-go/common/errors/annotate_example_test.go:25 - errors.someLibFunc()
- // reason: "processing 3"
- // "i" = 0
- // "secret" = value
- // "val" = 3
+ // reason: processing 3
+ // internal reason: secret(value)/i(0)
//
// From frame 3 to 4, the following wrappers were found:
- // MultiError 1/1: following first non-nil error.
- // "non-nil" = 1
- // "total" = 1
+ // internal reason: MultiError 1/1: following first non-nil error.
//
- // #? github.com/luci/luci-go/common/errors/annotate_example_test.go:51 - errors.someIntermediateFunc.func1()
- // reason: "could not process"
+ // #? github.com/luci/luci-go/common/errors/annotate_example_test.go:49 - errors.someIntermediateFunc.func1()
+ // reason: could not process
//
// ... skipped SOME frames in pkg "runtime"...
//
// GOROUTINE LINE
- // #? github.com/luci/luci-go/common/errors/annotate_example_test.go:60 - errors.someIntermediateFunc()
- // reason: "while processing [3]"
- // "vals" = []int{3}
+ // #? github.com/luci/luci-go/common/errors/annotate_example_test.go:58 - errors.someIntermediateFunc()
+ // reason: while processing [3]
//
- // #? github.com/luci/luci-go/common/errors/annotate_example_test.go:66 - errors.ExampleAnnotate()
- // reason: "top level"
+ // #? github.com/luci/luci-go/common/errors/annotate_example_test.go:64 - errors.ExampleAnnotate()
+ // reason: top level
//
// #? testing/example.go:XXX - testing.runExample()
// #? testing/example.go:XXX - testing.runExamples()
diff --git a/common/errors/annotate_test.go b/common/errors/annotate_test.go
index 283077a..733507e 100644
--- a/common/errors/annotate_test.go
+++ b/common/errors/annotate_test.go
@@ -5,7 +5,6 @@
package errors
import (
- "fmt"
"regexp"
"strings"
"testing"
@@ -19,7 +18,7 @@
fixTestingLine = regexp.MustCompile(`(testing/\w+.go):\d+`)
)
-func FixForTest(lines Lines) Lines {
+func FixForTest(lines []string) []string {
for i, l := range lines {
switch {
case strings.HasPrefix(l, "goroutine"):
@@ -40,11 +39,8 @@
t.Parallel()
Convey("Test annotation struct", t, func() {
- e := (Annotate(New("bad thing")).
- Reason("%(first)d some error: %(second)q").
- D("extra", 8.2, "%.3f").
- D("first", 20, "0x%08x").
- D("second", "stringy").Err())
+ e := Annotate(New("bad thing"), "%d some error: %q", 20, "stringy").
+ InternalReason("extra(%.3f)", 8.2).Err()
ae := e.(*annotatedError)
Convey("annotation can render itself for public usage", func() {
@@ -52,91 +48,53 @@
})
Convey("annotation can render itself for internal usage", func() {
- lines := RenderStack(e).ToLines(
- `runtime`, `github.com/jtolds/gls`,
+ lines := RenderStack(e, `runtime`, `github.com/jtolds/gls`,
`github.com/smartystreets/goconvey/convey`)
FixForTest(lines)
- So(lines, ShouldResemble, Lines{
+ So(lines, ShouldResemble, []string{
`original error: bad thing`,
``,
`GOROUTINE LINE`,
- `#? github.com/luci/luci-go/common/errors/annotate_test.go:47 - errors.TestAnnotation.func1()`,
- ` reason: "20 some error: \"stringy\""`,
- ` "extra" = 8.200`,
- ` "first" = 0x00000014`,
- ` "second" = "stringy"`,
+ `#? github.com/luci/luci-go/common/errors/annotate_test.go:43 - errors.TestAnnotation.func1()`,
+ ` reason: 20 some error: "stringy"`,
+ ` internal reason: extra(8.200)`,
``,
`... skipped SOME frames in pkg "github.com/smartystreets/goconvey/convey"...`,
`... skipped SOME frames in pkg "github.com/jtolds/gls"...`,
`... skipped SOME frames in pkg "github.com/smartystreets/goconvey/convey"...`,
``,
- `#? github.com/luci/luci-go/common/errors/annotate_test.go:110 - errors.TestAnnotation()`,
+ `#? github.com/luci/luci-go/common/errors/annotate_test.go:99 - errors.TestAnnotation()`,
`#? testing/testing.go:XXX - testing.tRunner()`,
`... skipped SOME frames in pkg "runtime"...`,
})
})
Convey("can render whole stack", func() {
- e = Annotate(e).Reason("outer frame %(first)s").D("first", "outer").Err()
- lines := RenderStack(e).ToLines(
- `runtime`, `github.com/jtolds/gls`,
+ e = Annotate(e, "outer frame %s", "outer").Err()
+ lines := RenderStack(e, `runtime`, `github.com/jtolds/gls`,
`github.com/smartystreets/goconvey/convey`)
FixForTest(lines)
- So(lines, ShouldResemble, Lines{
+ So(lines, ShouldResemble, []string{
`original error: bad thing`,
``,
`GOROUTINE LINE`,
- `#? github.com/luci/luci-go/common/errors/annotate_test.go:47 - errors.TestAnnotation.func1()`,
+ `#? github.com/luci/luci-go/common/errors/annotate_test.go:43 - errors.TestAnnotation.func1()`,
` annotation #0:`,
- ` reason: "outer frame outer"`,
- ` "first" = "outer"`,
+ ` reason: outer frame outer`,
` annotation #1:`,
- ` reason: "20 some error: \"stringy\""`,
- ` "extra" = 8.200`,
- ` "first" = 0x00000014`,
- ` "second" = "stringy"`,
+ ` reason: 20 some error: "stringy"`,
+ ` internal reason: extra(8.200)`,
``,
`... skipped SOME frames in pkg "github.com/smartystreets/goconvey/convey"...`,
`... skipped SOME frames in pkg "github.com/jtolds/gls"...`,
`... skipped SOME frames in pkg "github.com/smartystreets/goconvey/convey"...`,
``,
- `#? github.com/luci/luci-go/common/errors/annotate_test.go:110 - errors.TestAnnotation()`,
+ `#? github.com/luci/luci-go/common/errors/annotate_test.go:99 - errors.TestAnnotation()`,
`#? testing/testing.go:XXX - testing.tRunner()`,
`... skipped SOME frames in pkg "runtime"...`,
})
})
})
}
-
-func TestDataFormat(t *testing.T) {
- t.Parallel()
-
- testCases := []struct {
- format string
- expected string
- }{
- {"", ""},
- {"no replacements", `no replacements`},
- {"%(foo)s", `bar`},
- {"%%(foo)s", `%(foo)s`},
- {"%(foo)s|%(foo)s|%(foo)s", `bar|bar|bar`},
- {"|%(foo)s|%(foo)s|%(foo)s|", `|bar|bar|bar|`},
- {"%(missing)s", `MISSING(key="missing")`},
- {"replacing %(foo)q", `replacing "bar"`},
- {"replacing (%(foo)q)", `replacing ("bar")`},
- }
-
- Convey(`A testing Data object`, t, func() {
- data := Data{
- "foo": {"bar", ""},
- }
-
- for _, testCase := range testCases {
- Convey(fmt.Sprintf(`Formatting %q yields: %q`, testCase.format, testCase.expected), func() {
- So(data.Format(testCase.format), ShouldEqual, testCase.expected)
- })
- }
- })
-}
diff --git a/common/errors/multierror.go b/common/errors/multierror.go
index 976f08e..18e6ee9 100644
--- a/common/errors/multierror.go
+++ b/common/errors/multierror.go
@@ -52,11 +52,8 @@
n, _ := m.Summary()
return stackContext{
- internalReason: "MultiError %(non-nil)d/%(total)d: following first non-nil error.",
- data: Data{
- "non-nil": {Value: n},
- "total": {Value: len(m)},
- },
+ internalReason: fmt.Sprintf(
+ "MultiError %d/%d: following first non-nil error.", n, len(m)),
}
}
diff --git a/common/errors/tags.go b/common/errors/tags.go
index b80f135..ce963d8 100644
--- a/common/errors/tags.go
+++ b/common/errors/tags.go
@@ -4,12 +4,9 @@
package errors
-type (
- // TagKeyOrValue is used for functions taking either a TagKey or a TagValue.
- TagKeyOrValue interface {
- isTagKeyOrValue()
- }
+import "sort"
+type (
tagDescription struct {
description string
}
@@ -18,6 +15,8 @@
// errors. See NewTag for details.
TagKey *tagDescription
+ tagKeySlice []TagKey
+
// TagValue represents a (tag, value) to be used with Annotate.Tag, or may be
// applied to an error directly with the Apply method.
//
@@ -36,6 +35,12 @@
}
)
+var _ sort.Interface = tagKeySlice(nil)
+
+func (s tagKeySlice) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+func (s tagKeySlice) Len() int { return len(s) }
+func (s tagKeySlice) Less(i, j int) bool { return s[i].description < s[j].description }
+
// TagValueIn will retrieve the tagged value from the error that's associated
// with this key, and a boolean indicating if the tag was present or not.
func TagValueIn(t TagKey, err error) (value interface{}, ok bool) {
@@ -54,7 +59,7 @@
func (t TagValue) GenerateErrorTagValue() TagValue { return t }
// Apply applies this tag value (key+value) directly to the error. This is
-// a shortcut for `errors.Annotate(err).Tag(t).Err()`.
+// a shortcut for `errors.Annotate(err, "").Tag(t).Err()`.
func (t TagValue) Apply(err error) error {
if err == nil {
return nil
@@ -63,11 +68,6 @@
return a.Tag(t).Err()
}
-// MkTagValue is a shortcut for errors.TagValue{Key: key, Value: val}.
-func MkTagValue(key TagKey, val interface{}) TagValue {
- return TagValue{key, val}
-}
-
// BoolTag is an error tag implementation which holds a boolean value.
//
// It should be constructed like:
@@ -118,7 +118,7 @@
// type SomeType int
// type myTag struct { Key errors.TagKey }
// func (m myTag) With(value SomeType) errors.TagValue {
-// return errors.MkTagValue(vm.Key, value)
+// return errors.TagValue{Key: vm.Key, Value: value}
// }
// func (m myTag) In(err error) (v SomeType, ok bool) {
// d, ok := errors.TagValueIn(m.Key, err)
diff --git a/common/errors/walk.go b/common/errors/walk.go
index f313626..5b80d26 100644
--- a/common/errors/walk.go
+++ b/common/errors/walk.go
@@ -55,11 +55,3 @@
})
return
}
-
-// Contains performs a Walk traversal of an error, returning true if it is or
-// contains the supplied sentinel error.
-func Contains(err, sentinel error) bool {
- return Any(err, func(err error) bool {
- return err == sentinel
- })
-}
diff --git a/common/errors/walk_test.go b/common/errors/walk_test.go
index e21e3b8..0834d08 100644
--- a/common/errors/walk_test.go
+++ b/common/errors/walk_test.go
@@ -66,7 +66,7 @@
for _, err := range []error{
testErr,
MultiError{errors.New("other error"), MultiError{testErr, nil}},
- Annotate(testErr).Reason("error test").Err(),
+ Annotate(testErr, "error test").Err(),
} {
Convey(fmt.Sprintf(`Registers true for %T %v`, err, err), func() {
So(Any(err, filter), ShouldBeTrue)
@@ -74,30 +74,3 @@
}
})
}
-
-func TestContains(t *testing.T) {
- t.Parallel()
-
- Convey(`Testing the Contains function for a sentinel error`, t, func() {
- sentinel := errors.New("test error")
-
- for _, err := range []error{
- nil,
- errors.New("foo"),
- errors.New("test error"),
- } {
- Convey(fmt.Sprintf(`Registers false for %T %v`, err, err), func() {
- So(Contains(err, sentinel), ShouldBeFalse)
- })
- }
-
- for _, err := range []error{
- sentinel,
- MultiError{errors.New("other error"), MultiError{sentinel, nil}},
- } {
- Convey(fmt.Sprintf(`Registers true for %T %v`, err, err), func() {
- So(Contains(err, sentinel), ShouldBeTrue)
- })
- }
- })
-}
diff --git a/common/lhttp/client.go b/common/lhttp/client.go
index e75f666..0d0dc29 100644
--- a/common/lhttp/client.go
+++ b/common/lhttp/client.go
@@ -91,13 +91,13 @@
switch {
case status == 408, status == 429, status >= 500:
// The HTTP status code means the request should be retried.
- err = errors.Reason("http request failed: %(text)s (HTTP %(code)d)").
- D("text", http.StatusText(status)).D("code", status).Tag(transient.Tag).Err()
+ err = errors.Reason("http request failed: %s (HTTP %d)", http.StatusText(status), status).
+ Tag(transient.Tag).Err()
case status == 404 && strings.HasPrefix(req.URL.Path, "/_ah/api/"):
// Endpoints occasionally return 404 on valid requests!
logging.Infof(ctx, "lhttp.Do() got a Cloud Endpoints 404: %#v", resp.Header)
- err = errors.Reason("http request failed (endpoints): %(text)s (HTTP %(code)d)").
- D("text", http.StatusText(status)).D("code", status).Tag(transient.Tag).Err()
+ err = errors.Reason("http request failed (endpoints): %s (HTTP %d)", http.StatusText(status), status).
+ Tag(transient.Tag).Err()
case status >= 400:
// Any other failure code is a hard failure.
err = fmt.Errorf("http request failed: %s (HTTP %d)", http.StatusText(status), status)
@@ -158,8 +158,7 @@
}
if err := json.NewDecoder(resp.Body).Decode(out); err != nil {
// Retriable.
- return errors.Annotate(err).Reason("bad response %(url)s").
- D("url", url).Tag(transient.Tag).Err()
+ return errors.Annotate(err, "bad response %s", url).Tag(transient.Tag).Err()
}
return nil
}, nil), nil
diff --git a/common/runtime/profiling/profiler.go b/common/runtime/profiling/profiler.go
index 13d210f..2f31d3a 100644
--- a/common/runtime/profiling/profiler.go
+++ b/common/runtime/profiling/profiler.go
@@ -95,7 +95,7 @@
if p.ProfileCPU {
out, err := os.Create(p.generateOutPath("cpu"))
if err != nil {
- return errors.Annotate(err).Reason("failed to create CPU profile output file").Err()
+ return errors.Annotate(err, "failed to create CPU profile output file").Err()
}
pprof.StartCPUProfile(out)
p.profilingCPU = true
@@ -103,7 +103,7 @@
if p.BindHTTP != "" {
if err := p.startHTTP(); err != nil {
- return errors.Annotate(err).Reason("failed to start HTTP server").Err()
+ return errors.Annotate(err, "failed to start HTTP server").Err()
}
}
@@ -126,8 +126,7 @@
// Bind to our profiling port.
l, err := net.Listen("tcp4", p.BindHTTP)
if err != nil {
- return errors.Annotate(err).Reason("failed to bind to TCP4 address: %(addr)q").
- D("addr", p.BindHTTP).Err()
+ return errors.Annotate(err, "failed to bind to TCP4 address: %q", p.BindHTTP).Err()
}
server := http.Server{
@@ -168,7 +167,7 @@
if p.ProfileHeap {
if err := p.dumpHeapProfile(); err != nil {
- return errors.Annotate(err).Reason("failed to dump heap profile").Err()
+ return errors.Annotate(err, "failed to dump heap profile").Err()
}
}
@@ -178,14 +177,14 @@
func (p *Profiler) dumpHeapProfile() error {
fd, err := os.Create(p.generateOutPath("memory"))
if err != nil {
- return errors.Annotate(err).Reason("failed to create output file").Err()
+ return errors.Annotate(err, "failed to create output file").Err()
}
defer fd.Close()
// Get up-to-date statistics.
runtime.GC()
if err := pprof.WriteHeapProfile(fd); err != nil {
- return errors.Annotate(err).Reason("failed to write heap profile").Err()
+ return errors.Annotate(err, "failed to write heap profile").Err()
}
return nil
}
diff --git a/common/system/filesystem/filesystem.go b/common/system/filesystem/filesystem.go
index 3334072..c975461 100644
--- a/common/system/filesystem/filesystem.go
+++ b/common/system/filesystem/filesystem.go
@@ -19,7 +19,7 @@
// mask to all created directories.
func MakeDirs(path string) error {
if err := os.MkdirAll(path, 0755); err != nil {
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
}
return nil
}
@@ -29,9 +29,8 @@
func AbsPath(base *string) error {
v, err := filepath.Abs(*base)
if err != nil {
- return errors.Annotate(err).Reason("unable to resolve absolute path").
- D("base", *base).
- Err()
+ return errors.Annotate(err, "unable to resolve absolute path").
+ InternalReason("base(%q)", *base).Err()
}
*base = v
return nil
@@ -45,7 +44,7 @@
fd, err := os.OpenFile(path, (os.O_CREATE | os.O_RDWR), mode)
if err == nil {
if err := fd.Close(); err != nil {
- return errors.Annotate(err).Reason("failed to close new file").Err()
+ return errors.Annotate(err, "failed to close new file").Err()
}
if when.IsZero() {
// If "now" was specified, and we created a new file, then its times will
@@ -62,9 +61,7 @@
when = time.Now()
}
if err := os.Chtimes(path, when, when); err != nil {
- return errors.Annotate(err).Reason("failed to Chtimes").
- D("path", path).
- Err()
+ return errors.Annotate(err, "failed to Chtimes").InternalReason("path(%q)", path).Err()
}
return nil
@@ -78,9 +75,7 @@
if fi == nil {
var err error
if fi, err = os.Lstat(path); err != nil {
- return errors.Annotate(err).Reason("could not Lstat path").
- D("path", path).
- Err()
+ return errors.Annotate(err, "could not Lstat path").InternalReason("path(%q)", path).Err()
}
}
@@ -89,24 +84,17 @@
if (mode & 0200) == 0 {
mode |= 0200
if err := os.Chmod(path, mode); err != nil {
- return errors.Annotate(err).Reason("could not Chmod path").
- D("mode", mode).
- D("path", path).
- Err()
+ return errors.Annotate(err, "could not Chmod path").InternalReason("mode(%#o)/path(%q)", mode, path).Err()
}
}
if err := os.Remove(path); err != nil {
- return errors.Annotate(err).Reason("failed to remove path").
- D("path", path).
- Err()
+ return errors.Annotate(err, "failed to remove path").InternalReason("path(%q)", path).Err()
}
return nil
})
if err != nil {
- return errors.Annotate(err).Reason("failed to recurisvely remove path").
- D("path", path).
- Err()
+ return errors.Annotate(err, "failed to recurisvely remove path").InternalReason("path(%q)", path).Err()
}
return nil
}
@@ -126,23 +114,21 @@
err := filepath.Walk(path, func(path string, info os.FileInfo, err error) error {
if err != nil {
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
}
mode := info.Mode()
if (mode.IsRegular() || mode.IsDir()) && filter(path) {
if newMode := chmod(mode); newMode != mode {
if err := os.Chmod(path, newMode); err != nil {
- return errors.Annotate(err).Reason("failed to Chmod").
- D("path", path).
- Err()
+ return errors.Annotate(err, "failed to Chmod").InternalReason("path(%q)", path).Err()
}
}
}
return nil
})
if err != nil {
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
}
return nil
}
diff --git a/common/system/filesystem/filesystem_test.go b/common/system/filesystem/filesystem_test.go
index 0deb1a5..6c346bd 100644
--- a/common/system/filesystem/filesystem_test.go
+++ b/common/system/filesystem/filesystem_test.go
@@ -53,7 +53,7 @@
So(IsNotExist(errors.New("something")), ShouldBeFalse)
So(IsNotExist(err), ShouldBeTrue)
- So(IsNotExist(errors.Annotate(err).Reason("annotated").Err()), ShouldBeTrue)
+ So(IsNotExist(errors.Annotate(err, "annotated").Err()), ShouldBeTrue)
})
})
}
diff --git a/common/system/prober/probe.go b/common/system/prober/probe.go
index 3965f90..f6282c9 100644
--- a/common/system/prober/probe.go
+++ b/common/system/prober/probe.go
@@ -85,14 +85,12 @@
// Get the authoritative executable from the system.
exec, err := os.Executable()
if err != nil {
- return errors.Annotate(err).Reason("failed to get executable").Err()
+ return errors.Annotate(err, "failed to get executable").Err()
}
execStat, err := os.Stat(exec)
if err != nil {
- return errors.Annotate(err).Reason("failed to stat executable: %(path)s").
- D("path", exec).
- Err()
+ return errors.Annotate(err, "failed to stat executable: %s", exec).Err()
}
// Before using "os.Executable" result, which is known to resolve symlinks on
@@ -188,9 +186,7 @@
}
return "", errors.Reason("could not find target in system").
- D("target", p.Target).
- D("dirs", pathDirs).
- Err()
+ InternalReason("target(%s)/dirs(%v)", p.Target, pathDirs).Err()
}
// checkDir checks "checkDir" for our Target executable. It ignores
diff --git a/common/tsmon/config.go b/common/tsmon/config.go
index 26d63c0..1fc6e2e 100644
--- a/common/tsmon/config.go
+++ b/common/tsmon/config.go
@@ -37,7 +37,7 @@
decoder := json.NewDecoder(file)
if err = decoder.Decode(&ret); err != nil {
- return ret, errors.Annotate(err).Reason("failed to decode file").Err()
+ return ret, errors.Annotate(err, "failed to decode file").Err()
}
return ret, nil
@@ -48,7 +48,7 @@
default:
// An unexpected failure occurred.
- return ret, errors.Annotate(err).Reason("failed to open file").Err()
+ return ret, errors.Annotate(err, "failed to open file").Err()
}
}
diff --git a/common/tsmon/iface.go b/common/tsmon/iface.go
index 53ae4aa..1c18c69 100644
--- a/common/tsmon/iface.go
+++ b/common/tsmon/iface.go
@@ -80,8 +80,7 @@
// Load the config file, and override its values with flags.
config, err := loadConfig(fl.ConfigFile)
if err != nil {
- return errors.Annotate(err).Reason("failed to load config file at [%(path)s]").
- D("path", fl.ConfigFile).Err()
+ return errors.Annotate(err, "failed to load config file at [%s]", fl.ConfigFile).Err()
}
if fl.Endpoint != "" {
@@ -97,7 +96,7 @@
mon, err := initMonitor(c, config)
switch {
case err != nil:
- return errors.Annotate(err).Reason("failed to initialize monitor").Err()
+ return errors.Annotate(err, "failed to initialize monitor").Err()
case mon == nil:
return nil // tsmon is disabled
}
@@ -126,7 +125,7 @@
fl.Target.SetDefaultsFromHostname()
t, err := target.NewFromFlags(&fl.Target)
if err != nil {
- return errors.Annotate(err).Reason("failed to configure target from flags").Err()
+ return errors.Annotate(err, "failed to configure target from flags").Err()
}
Initialize(c, mon, store.NewInMemory(t))
diff --git a/deploytool/api/deploy/util.go b/deploytool/api/deploy/util.go
index af98054..403b676 100644
--- a/deploytool/api/deploy/util.go
+++ b/deploytool/api/deploy/util.go
@@ -156,7 +156,7 @@
return AppEngineResources_Index_DESCENDING, nil
default:
- return 0, errors.Reason("invalid index direction %(value)q").D("value", v).Err()
+ return 0, errors.Reason("invalid index direction %q", v).Err()
}
}
diff --git a/deploytool/cmd/luci_deploy/appengine.go b/deploytool/cmd/luci_deploy/appengine.go
index 6e0e01b..6d8fb60 100644
--- a/deploytool/cmd/luci_deploy/appengine.go
+++ b/deploytool/cmd/luci_deploy/appengine.go
@@ -193,7 +193,7 @@
isStub = true
default:
- return nil, errors.Reason("unsupported runtime %(runtime)q").D("runtime", aem.Runtime).Err()
+ return nil, errors.Reason("unsupported runtime %q", aem.Runtime).Err()
}
// Classic / Managed VM Properties
@@ -232,7 +232,7 @@
icPrefix = "B"
default:
- return nil, errors.Reason("unknown scaling type %(type)T").D("type", sc).Err()
+ return nil, errors.Reason("unknown scaling type %T", sc).Err()
}
appYAML.InstanceClass = p.Classic.InstanceClass.AppYAMLString(icPrefix)
@@ -275,8 +275,8 @@
entry.StaticFiles = filepath.Join(relDir, sf.UrlMap)
default:
- return nil, errors.Reason("don't know how to handle content %(content)T").
- D("content", t).D("url", handler.Url).Err()
+ return nil, errors.Reason("don't know how to handle content %T", t).
+ InternalReason("url(%q)", handler.Url).Err()
}
if entry.Script != "" && isStub {
@@ -338,8 +338,7 @@
}
}
if count := len(dispatchYAML.Dispatch); count > 10 {
- return nil, errors.Reason("dispatch file has more than 10 routing rules (%(count)d)").
- D("count", count).Err()
+ return nil, errors.Reason("dispatch file has more than 10 routing rules (%d)", count).Err()
}
return &dispatchYAML, nil
}
@@ -369,7 +368,7 @@
}
default:
- return nil, errors.Reason("unknown task queue type %(type)T").D("type", t).Err()
+ return nil, errors.Reason("unknown task queue type %T", t).Err()
}
queueYAML.Queue = append(queueYAML.Queue, &entry)
@@ -383,13 +382,12 @@
func loadIndexYAMLResource(path string) (*deploy.AppEngineResources, error) {
data, err := ioutil.ReadFile(path)
if err != nil {
- return nil, errors.Annotate(err).Reason("failed to load [%(path)s]").D("path", path).Err()
+ return nil, errors.Annotate(err, "failed to load [%s]", path).Err()
}
var indexYAML gaeIndexYAML
if err := yaml.Unmarshal(data, &indexYAML); err != nil {
- return nil, errors.Annotate(err).Reason("could not load 'index.yaml' from [%(path)s]").
- D("path", path).Err()
+ return nil, errors.Annotate(err, "could not load 'index.yaml' from [%s]", path).Err()
}
var res deploy.AppEngineResources
@@ -404,8 +402,8 @@
for pidx, idxProp := range idx.Properties {
dir, err := deploy.IndexDirectionFromAppYAMLString(idxProp.Direction)
if err != nil {
- return nil, errors.Annotate(err).Reason("could not identify direction for entry").
- D("index", i).D("propertyIndex", pidx).Err()
+ return nil, errors.Annotate(err, "could not identify direction for entry").
+ InternalReason("index(%d)/propertyIndex(%d)", i, pidx).Err()
}
entry.Property[pidx] = &deploy.AppEngineResources_Index_Property{
diff --git a/deploytool/cmd/luci_deploy/build.go b/deploytool/cmd/luci_deploy/build.go
index 656e742..292ed7b 100644
--- a/deploytool/cmd/luci_deploy/build.go
+++ b/deploytool/cmd/luci_deploy/build.go
@@ -35,8 +35,7 @@
// to update its directory.
func buildComponent(w *work, c *layoutDeploymentComponent, root *managedfs.Dir) error {
if src := c.source(); !src.Source.RunScripts {
- return errors.Reason("refusing to run scripts (run_scripts is false for %(source)q)").
- D("source", src.title).Err()
+ return errors.Reason("refusing to run scripts (run_scripts is false for %q)", src.title).Err()
}
// Create our build directories and map them to variables.
@@ -44,12 +43,12 @@
dirs := make([]*managedfs.Dir, len(c.Build))
for i, b := range c.Build {
if _, has := c.buildDirs[b.DirKey]; has {
- return errors.Reason("duplicate build key [%(key)s]").D("key", b.DirKey).Err()
+ return errors.Reason("duplicate build key [%s]", b.DirKey).Err()
}
dir, err := root.EnsureDirectory(fmt.Sprintf("%d_%s", i, flattenVarToDir(b.DirKey)))
if err != nil {
- return errors.Annotate(err).Reason("failed to create build directory").Err()
+ return errors.Annotate(err, "failed to create build directory").Err()
}
dirs[i] = dir
@@ -58,7 +57,7 @@
// Apply build directories.
if err := c.expandPaths(); err != nil {
- return errors.Annotate(err).Reason("failed to expand component paths").Err()
+ return errors.Annotate(err, "failed to expand component paths").Err()
}
// Run all of our build scripts in parallel.
@@ -71,7 +70,7 @@
}
})
if err != nil {
- return errors.Annotate(err).Reason("failed to run component builds").Err()
+ return errors.Annotate(err, "failed to run component builds").Err()
}
return nil
}
@@ -96,11 +95,11 @@
args = append(args, ps.ExtraArgs...)
if err := python.exec(scriptPath, args...).cwd(buildDir).check(w); err != nil {
- return errors.Annotate(err).Reason("failed to execute [%(scriptPath)s]").D("scriptPath", scriptPath).Err()
+ return errors.Annotate(err, "failed to execute [%s]", scriptPath).Err()
}
return nil
default:
- return errors.Reason("unknown build type %(type)T").D("type", t).Err()
+ return errors.Reason("unknown build type %T", t).Err()
}
}
diff --git a/deploytool/cmd/luci_deploy/checkout.go b/deploytool/cmd/luci_deploy/checkout.go
index 3f93db2..048b285 100644
--- a/deploytool/cmd/luci_deploy/checkout.go
+++ b/deploytool/cmd/luci_deploy/checkout.go
@@ -76,7 +76,7 @@
func checkout(w *work, l *deployLayout, applyOverrides bool) error {
frozen, err := l.initFrozenCheckout(w)
if err != nil {
- return errors.Annotate(err).Reason("failed to initialize checkout").Err()
+ return errors.Annotate(err, "failed to initialize checkout").Err()
}
// reg is our internal checkout registry. This represents the actual
@@ -84,17 +84,16 @@
// repository will be deduplicated here.
fs, err := l.workingFilesystem()
if err != nil {
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
}
checkoutDir, err := fs.Base().EnsureDirectory(checkoutsSubdir)
if err != nil {
- return errors.Annotate(err).Reason("failed to create checkout directory").Err()
+ return errors.Annotate(err, "failed to create checkout directory").Err()
}
repoDir, err := checkoutDir.EnsureDirectory("repository")
if err != nil {
- return errors.Annotate(err).Reason("failed to create repository directory %(dir)q").
- D("dir", repoDir).Err()
+ return errors.Annotate(err, "failed to create repository directory %q", repoDir).Err()
}
reg := checkoutRegistry{
@@ -132,8 +131,7 @@
}
if err := sc.addRegistryRepos(®); err != nil {
- return errors.Annotate(err).Reason("failed to add [%(sourceCheckout)s] to registry").
- D("sourceCheckout", sc).Err()
+ return errors.Annotate(err, "failed to add [%s] to registry", sc).Err()
}
// If we're overriding sources, and this source is overridden, then apply
@@ -151,8 +149,7 @@
sc.FrozenLayout_Source.Source.Tainted = true
if err := sc.addRegistryRepos(®); err != nil {
- return errors.Annotate(err).Reason("failed to add (overridden) [%(sourceCheckout)s] to registry").
- D("sourceCheckout", sc).Err()
+ return errors.Annotate(err, "failed to add (overridden) [%s] to registry", sc).Err()
}
}
}
@@ -164,13 +161,13 @@
sgSources[sgKey] = groupSrcs
}
if err := reg.checkout(w); err != nil {
- return errors.Annotate(err).Reason("failed to checkout sources").Err()
+ return errors.Annotate(err, "failed to checkout sources").Err()
}
// Execute each source checkout in parallel.
sourcesDir, err := checkoutDir.EnsureDirectory("sources")
if err != nil {
- return errors.Annotate(err).Reason("failed to create sources directory").Err()
+ return errors.Annotate(err, "failed to create sources directory").Err()
}
err = w.RunMulti(func(workC chan<- func() error) {
@@ -179,12 +176,11 @@
workC <- func() error {
root, err := sourcesDir.EnsureDirectory(sc.group, sc.name)
if err != nil {
- return errors.Annotate(err).Reason("failed to create checkout directory").Err()
+ return errors.Annotate(err, "failed to create checkout directory").Err()
}
if err := sc.checkout(w, root); err != nil {
- return errors.Annotate(err).Reason("failed to checkout %(sourceCheckout)s").
- D("sourceCheckout", sc).Err()
+ return errors.Annotate(err, "failed to checkout %s", sc).Err()
}
return nil
}
@@ -205,8 +201,7 @@
hash := sha256.New()
for _, sc := range sgSources[sgKey] {
if sc.Revision == "" {
- return errors.Reason("source %(sourceCheckout)q has an empty revision").
- D("sourceCheckout", sc.String()).Err()
+ return errors.Reason("source %q has an empty revision", sc).Err()
}
fmt.Fprintf(hash, "%s@%s\x00", sc.name, sc.Revision)
@@ -228,11 +223,11 @@
// Create the frozen checkout file.
frozenFile := checkoutDir.File(frozenCheckoutName)
if err := frozenFile.GenerateTextProto(w, frozen); err != nil {
- return errors.Annotate(err).Reason("failed to create frozen checkout protobuf").Err()
+ return errors.Annotate(err, "failed to create frozen checkout protobuf").Err()
}
if err := checkoutDir.CleanUp(); err != nil {
- return errors.Annotate(err).Reason("failed to do full cleanup of cleanup sources filesystem").Err()
+ return errors.Annotate(err, "failed to do full cleanup of cleanup sources filesystem").Err()
}
return nil
@@ -243,7 +238,7 @@
var frozen deploy.FrozenLayout
if err := unmarshalTextProtobuf(path, &frozen); err != nil {
- return nil, errors.Annotate(err).Err()
+ return nil, errors.Annotate(err, "").Err()
}
return &frozen, nil
}
@@ -277,7 +272,7 @@
u, err := url.Parse(g.Url)
if err != nil {
- return errors.Annotate(err).Reason("failed to parse Git URL [%(url)s]").D("url", g.Url).Err()
+ return errors.Annotate(err, "failed to parse Git URL [%s]", g.Url).Err()
}
// Add a Git checkout operation for this source to the registry.
@@ -302,12 +297,12 @@
// Add a symlink between our raw checkout and our current checkout.
if err := checkoutPath.SymlinkFrom(sc.cs.path, true); err != nil {
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
}
sc.Relpath = checkoutPath.RelPath()
default:
- return errors.Reason("don't know how to checkout %(type)T").D("type", t).Err()
+ return errors.Reason("don't know how to checkout %T", t).Err()
}
sc.Revision = sc.cs.revision
@@ -400,7 +395,7 @@
// Perform the actual checkout operation.
checkoutDir, err := reg.repoDir.EnsureDirectory(hex.EncodeToString(pathHash[:]))
if err != nil {
- return errors.Annotate(err).Reason("failed to create checkout directory for %(key)q").D("key", key).Err()
+ return errors.Annotate(err, "failed to create checkout directory for %q", key).Err()
}
log.Fields{
@@ -419,7 +414,7 @@
// If there is a deployment configuration, load/parse/execute it.
sl, err := loadSourceLayout(cs.path)
if err != nil {
- return errors.Annotate(err).Reason("failed to load source layout").Err()
+ return errors.Annotate(err, "failed to load source layout").Err()
}
var sir deploy.SourceInitResult
@@ -431,8 +426,7 @@
for i, in := range sl.Init {
inResult, err := sourceInit(w, cs.path, in)
if err != nil {
- return errors.Annotate(err).Reason("failed to run source init #%(index)d").
- D("index", i).Err()
+ return errors.Annotate(err, "failed to run source init #%d", i).Err()
}
// Merge this SourceInitResult into the common repository
@@ -520,7 +514,7 @@
switch st, err := os.Stat(gitDir); {
case err == nil:
if !st.IsDir() {
- return errors.Reason("checkout Git path [%(path)s] exists, and is not a directory").D("path", gitDir).Err()
+ return errors.Reason("checkout Git path [%s] exists, and is not a directory", gitDir).Err()
}
case isNotExist(err):
@@ -533,12 +527,12 @@
return err
}
if err = git.exec(path, "update-ref", resetRef, ref).check(w); err != nil {
- return errors.Annotate(err).Reason("failed to checkout %(ref)q from %(url)q").D("ref", ref).D("url", g.url).Err()
+ return errors.Annotate(err, "failed to checkout %q from %q", ref, g.url).Err()
}
needsFetch = false
default:
- return errors.Annotate(err).Reason("failed to stat checkout Git directory [%(dir)s]").D("dir", gitDir).Err()
+ return errors.Annotate(err, "failed to stat checkout Git directory [%s]", gitDir).Err()
}
// Check out the desired commit/ref by resetting the repository.
@@ -548,7 +542,7 @@
x := git.exec(path, "rev-parse", ref)
switch rc, err := x.run(w); {
case err != nil:
- return errors.Annotate(err).Reason("failed to check for commit %(ref)q").D("ref", ref).Err()
+ return errors.Annotate(err, "failed to check for commit %q", ref).Err()
case rc == 0:
// If the ref resolved to itself, then it's a commit and it's already in the
@@ -563,14 +557,13 @@
// If our checkout isn't ready, fetch the ref remotely.
if needsFetch {
if err := git.exec(path, "fetch", "origin", fmt.Sprintf("%s:%s", ref, resetRef)).check(w); err != nil {
- return errors.Annotate(err).Reason("failed to fetch %(ref)q from remote").D("ref", ref).Err()
+ return errors.Annotate(err, "failed to fetch %q from remote", ref).Err()
}
}
// Reset to "resetRef".
if err := git.exec(path, "reset", "--hard", resetRef).check(w); err != nil {
- return errors.Annotate(err).Reason("failed to checkout %(ref)q (%(localRef)q) from %(url)q").
- D("ref", ref).D("localRef", resetRef).D("url", g.url).Err()
+ return errors.Annotate(err, "failed to checkout %q (%q) from %q", ref, resetRef, g.url).Err()
}
}
}
@@ -600,7 +593,7 @@
}
})
if err != nil {
- return errors.Annotate(err).Reason("failed to get Git repository properties").Err()
+ return errors.Annotate(err, "failed to get Git repository properties").Err()
}
// We're tainted if our merge base doesn't equal our current revision.
@@ -659,7 +652,7 @@
scriptPath := deployToNative(path, ps.Path)
if err := python.exec(scriptPath, path, resultPath).cwd(path).check(w); err != nil {
- return errors.Annotate(err).Reason("failed to execute [%(scriptPath)s]").D("scriptPath", scriptPath).Err()
+ return errors.Annotate(err, "failed to execute [%s]", scriptPath).Err()
}
switch err := unmarshalTextProtobuf(resultPath, &r); {
@@ -667,13 +660,12 @@
return nil
default:
- return errors.Annotate(err).Reason("failed to stat SourceInitResult [%(resultPath)s]").
- D("resultPath", resultPath).Err()
+ return errors.Annotate(err, "failed to stat SourceInitResult [%s]", resultPath).Err()
}
})
return &r, err
default:
- return nil, errors.Reason("unknown source init type %(type)T").D("type", t).Err()
+ return nil, errors.Reason("unknown source init type %T", t).Err()
}
}
diff --git a/deploytool/cmd/luci_deploy/config.go b/deploytool/cmd/luci_deploy/config.go
index 9846e3d..d206fb8 100644
--- a/deploytool/cmd/luci_deploy/config.go
+++ b/deploytool/cmd/luci_deploy/config.go
@@ -33,7 +33,7 @@
log.Debugf(c, "No user config found at: %s", configPath)
default:
- return errors.Annotate(err).Reason("failed to load config at [%(path)s]").D("path", configPath).Err()
+ return errors.Annotate(err, "failed to load config at [%s]", configPath).Err()
}
return nil
diff --git a/deploytool/cmd/luci_deploy/deploy.go b/deploytool/cmd/luci_deploy/deploy.go
index 1b2773d..9d6e3b1 100644
--- a/deploytool/cmd/luci_deploy/deploy.go
+++ b/deploytool/cmd/luci_deploy/deploy.go
@@ -109,13 +109,13 @@
if cmd.checkout {
// Perform a full checkout.
if err := checkout(w, &a.layout, false); err != nil {
- return errors.Annotate(err).Reason("failed to checkout sources").Err()
+ return errors.Annotate(err, "failed to checkout sources").Err()
}
}
// Load our frozen checkout.
if err := a.layout.loadFrozenLayout(w); err != nil {
- return errors.Annotate(err).Reason("failed to load frozen checkout").Err()
+ return errors.Annotate(err, "failed to load frozen checkout").Err()
}
return nil
})
@@ -150,7 +150,7 @@
err = a.runWork(c, func(w *work) error {
if err := cmd.dp.initialize(w, &a.layout); err != nil {
- return errors.Annotate(err).Reason("failed to initialize").Err()
+ return errors.Annotate(err, "failed to initialize").Err()
}
return cmd.dp.deploy(w)
@@ -231,8 +231,7 @@
pReg = &dp.reg
}
if err := comp.loadSourceComponent(pReg); err != nil {
- return errors.Annotate(err).Reason("failed to load component %(comp)q").
- D("comp", comp.String()).Err()
+ return errors.Annotate(err, "failed to load component %q", comp).Err()
}
}
}
@@ -244,17 +243,17 @@
// Create our working root and staging/build subdirectories.
fs, err := dp.layout.workingFilesystem()
if err != nil {
- return errors.Annotate(err).Reason("failed to create working directory").Err()
+ return errors.Annotate(err, "failed to create working directory").Err()
}
stagingDir, err := fs.Base().EnsureDirectory("staging")
if err != nil {
- return errors.Annotate(err).Reason("failed to create staging directory").Err()
+ return errors.Annotate(err, "failed to create staging directory").Err()
}
// Stage: Staging
if err := dp.reg.stage(w, stagingDir, &dp.params); err != nil {
- return errors.Annotate(err).Reason("failed to stage").Err()
+ return errors.Annotate(err, "failed to stage").Err()
}
if dp.params.stage <= deployStaging {
return nil
@@ -262,7 +261,7 @@
// Stage: Local Build
if err := dp.reg.localBuild(w); err != nil {
- return errors.Annotate(err).Reason("failed to perform local build").Err()
+ return errors.Annotate(err, "failed to perform local build").Err()
}
if dp.params.stage <= deployLocalBuild {
return nil
@@ -270,7 +269,7 @@
// Stage: Push
if err := dp.reg.push(w); err != nil {
- return errors.Annotate(err).Reason("failed to push components").Err()
+ return errors.Annotate(err, "failed to push components").Err()
}
if dp.params.stage <= deployPush {
return nil
@@ -278,7 +277,7 @@
// Stage: Commit
if err := dp.reg.commit(w); err != nil {
- return errors.Annotate(err).Reason("failed to commit").Err()
+ return errors.Annotate(err, "failed to commit").Err()
}
return nil
}
@@ -387,8 +386,7 @@
workC <- func() error {
depDir, err := stageDir.EnsureDirectory(string(proj.project.dep.title), "appengine")
if err != nil {
- return errors.Annotate(err).Reason("failed to create deployment directory for %(deployment)q").
- D("deployment", proj.project.dep.title).Err()
+ return errors.Annotate(err, "failed to create deployment directory for %q", proj.project.dep.title).Err()
}
return proj.stage(w, depDir, params)
}
@@ -400,8 +398,7 @@
workC <- func() error {
depDir, err := stageDir.EnsureDirectory(string(proj.project.dep.title), "container_engine")
if err != nil {
- return errors.Annotate(err).Reason("failed to create deployment directory for %(deployment)q").
- D("deployment", proj.project.dep.title).Err()
+ return errors.Annotate(err, "failed to create deployment directory for %q", proj.project.dep.title).Err()
}
return proj.stage(w, depDir, params)
}
diff --git a/deploytool/cmd/luci_deploy/deploy_appengine.go b/deploytool/cmd/luci_deploy/deploy_appengine.go
index 1367476..de0c916 100644
--- a/deploytool/cmd/luci_deploy/deploy_appengine.go
+++ b/deploytool/cmd/luci_deploy/deploy_appengine.go
@@ -83,7 +83,7 @@
// Generate a directory for our deployment's modules.
moduleBaseDir, err := root.EnsureDirectory("modules")
if err != nil {
- return errors.Annotate(err).Reason("failed to create modules directory").Err()
+ return errors.Annotate(err, "failed to create modules directory").Err()
}
// Stage each module in parallel. Also, generate AppEngine-wide YAMLs.
@@ -99,19 +99,17 @@
workC <- func() error {
moduleDir, err := moduleBaseDir.EnsureDirectory(string(module.comp.comp.title))
if err != nil {
- return errors.Annotate(err).Reason("failed to create module directory for %(module)q").
- D("module", module.comp.comp.title).Err()
+ return errors.Annotate(err, "failed to create module directory for %q", module.comp.comp.title).Err()
}
if err := module.stage(w, moduleDir, params); err != nil {
- return errors.Annotate(err).Reason("failed to stage module %(name)q").
- D("name", module.comp.comp.title).Err()
+ return errors.Annotate(err, "failed to stage module %q", module.comp.comp.title).Err()
}
return nil
}
}
})
if err != nil {
- return errors.Annotate(err).Reason("failed to stage modules").Err()
+ return errors.Annotate(err, "failed to stage modules").Err()
}
// Build our verison/module map for commit.
@@ -158,7 +156,7 @@
// GAE requirement for initial deployments.
if module := d.modules[gaeDefaultModule]; module != nil {
if err := module.pushFn(w); err != nil {
- return errors.Annotate(err).Reason("failed to push default module").Err()
+ return errors.Annotate(err, "failed to push default module").Err()
}
}
@@ -200,8 +198,7 @@
mod := mod
workC <- func() error {
if err := gcloud.exec("app", "versions", "migrate", "--service", mod, v).check(w); err != nil {
- return errors.Annotate(err).Reason("failed to set default version").
- D("version", v).Err()
+ return errors.Annotate(err, "failed to set default version: %q", v).Err()
}
return nil
}
@@ -209,7 +206,7 @@
}
})
if err != nil {
- return errors.Annotate(err).Reason("failed to set default versions").Err()
+ return errors.Annotate(err, "failed to set default versions").Err()
}
// If any modules were installed as default, push our new related configs.
@@ -223,10 +220,7 @@
deployablePath := d.yamlDir.File(deployable).String()
if err := gcloud.exec("app", "deploy", deployablePath).check(w); err != nil {
- return errors.Annotate(err).Reason("failed to deploy YAML %(deployable)q from [%(path)s]").
- D("deployable", deployable).
- D("path", deployablePath).
- Err()
+ return errors.Annotate(err, "failed to deploy YAML %q from [%s]", deployable, deployablePath).Err()
}
}
}
@@ -243,16 +237,16 @@
yamls["index.yaml"] = gaeBuildIndexYAML(d.project)
yamls["cron.yaml"] = gaeBuildCronYAML(d.project)
if yamls["dispatch.yaml"], err = gaeBuildDispatchYAML(d.project); err != nil {
- return errors.Annotate(err).Reason("failed to generate dispatch.yaml").Err()
+ return errors.Annotate(err, "failed to generate dispatch.yaml").Err()
}
if yamls["queue.yaml"], err = gaeBuildQueueYAML(d.project); err != nil {
- return errors.Annotate(err).Reason("failed to generate index.yaml").Err()
+ return errors.Annotate(err, "failed to generate index.yaml").Err()
}
for k, v := range yamls {
f := root.File(k)
if err := f.GenerateYAML(w, v); err != nil {
- return errors.Annotate(err).Reason("failed to generate %(yaml)q").D("yaml", k).Err()
+ return errors.Annotate(err, "failed to generate %q", k).Err()
}
}
@@ -302,7 +296,7 @@
var err error
m.version, err = makeCloudProjectVersion(m.comp.dep.cloudProject, m.comp.source())
if err != nil {
- return errors.Annotate(err).Reason("failed to calculate cloud project version").Err()
+ return errors.Annotate(err, "failed to calculate cloud project version").Err()
}
}
@@ -323,7 +317,7 @@
// interfere with app files.
deployDir, err := root.EnsureDirectory("__deploy")
if err != nil {
- return errors.Annotate(err).Reason("failed to create deploy directory").Err()
+ return errors.Annotate(err, "failed to create deploy directory").Err()
}
// Build each Component. We will delete any existing contents and leave it
@@ -331,16 +325,16 @@
// there.
buildDir, err := deployDir.EnsureDirectory("build")
if err != nil {
- return errors.Annotate(err).Reason("failed to create build directory").Err()
+ return errors.Annotate(err, "failed to create build directory").Err()
}
if err := buildDir.CleanUp(); err != nil {
- return errors.Annotate(err).Reason("failed to cleanup build directory").Err()
+ return errors.Annotate(err, "failed to cleanup build directory").Err()
}
buildDir.Ignore()
// Build our Component into this directory.
if err := buildComponent(w, m.comp, buildDir); err != nil {
- return errors.Annotate(err).Reason("failed to build component").Err()
+ return errors.Annotate(err, "failed to build component").Err()
}
switch t := m.GetRuntime().(type) {
@@ -350,24 +344,23 @@
// Construct a GOPATH for this module.
goPath, err := root.EnsureDirectory("gopath")
if err != nil {
- return errors.Annotate(err).Reason("failed to create GOPATH base").Err()
+ return errors.Annotate(err, "failed to create GOPATH base").Err()
}
if err := stageGoPath(w, m.comp, goPath); err != nil {
- return errors.Annotate(err).Reason("failed to stage GOPATH").Err()
+ return errors.Annotate(err, "failed to stage GOPATH").Err()
}
// Generate a stub Go package, which we will populate with an entry point.
goSrcDir, err := root.EnsureDirectory("src")
if err != nil {
- return errors.Annotate(err).Reason("failed to create stub source directory").Err()
+ return errors.Annotate(err, "failed to create stub source directory").Err()
}
mainPkg := fmt.Sprintf("%s/main", m.comp.comp.title)
mainPkgParts := strings.Split(mainPkg, "/")
mainPkgDir, err := goSrcDir.EnsureDirectory(mainPkgParts[0], mainPkgParts[1:]...)
if err != nil {
- return errors.Annotate(err).Reason("failed to create directory for main package %(pkg)q").
- D("pkg", mainPkg).Err()
+ return errors.Annotate(err, "failed to create directory for main package %q", mainPkg).Err()
}
m.goPath = []string{root.String(), goPath.String()}
@@ -380,11 +373,11 @@
// space is outside of the main package space.
pkgPath := findGoPackage(t.GoModule.EntryPackage, m.goPath)
if pkgPath == "" {
- return errors.Reason("unable to find path for %(package)q").D("package", t.GoModule.EntryPackage).Err()
+ return errors.Reason("unable to find path for %q", t.GoModule.EntryPackage).Err()
}
if err := mainPkgDir.ShallowSymlinkFrom(pkgPath, true); err != nil {
- return errors.Annotate(err).Reason("failed to create shallow symlink of main module").Err()
+ return errors.Annotate(err, "failed to create shallow symlink of main module").Err()
}
m.localBuildFn = func(w *work) error {
@@ -397,7 +390,7 @@
// Generate a classic GAE stub. Since GAE works through "init()", all this
// stub has to do is import the actual entry point package.
if err := m.writeGoClassicGAEStub(w, mainPkgDir, gom.EntryPackage); err != nil {
- return errors.Annotate(err).Reason("failed to generate GAE classic entry stub").Err()
+ return errors.Annotate(err, "failed to generate GAE classic entry stub").Err()
}
m.localBuildFn = func(w *work) error {
@@ -423,7 +416,7 @@
// under our deployment directory.
staticDir, err := deployDir.EnsureDirectory("static")
if err != nil {
- return errors.Annotate(err).Reason("failed to create static directory").Err()
+ return errors.Annotate(err, "failed to create static directory").Err()
}
staticMap := make(map[string]string)
@@ -449,7 +442,7 @@
// Get the actual path for this BuildPath entry.
dirPath, err := m.comp.buildPath(bp)
if err != nil {
- return errors.Annotate(err).Reason("cannot resolve static directory").Err()
+ return errors.Annotate(err, "cannot resolve static directory").Err()
}
// Do we already have a static map entry for this filesystem source path?
@@ -457,11 +450,10 @@
if !ok {
sd := staticDir.File(strconv.Itoa(len(staticMap)))
if err := sd.SymlinkFrom(dirPath, true); err != nil {
- return errors.Annotate(err).Reason("failed to symlink static content for [%(path)s]").
- D("path", dirPath).Err()
+ return errors.Annotate(err, "failed to symlink static content for [%s]", dirPath).Err()
}
if staticName, err = root.RelPathFrom(sd.String()); err != nil {
- return errors.Annotate(err).Reason("failed to get relative path").Err()
+ return errors.Annotate(err, "failed to get relative path").Err()
}
staticMap[dirPath] = staticName
}
@@ -472,7 +464,7 @@
// "app.yaml" / "module.yaml"
appYAML, err := gaeBuildAppYAML(m.AppEngineModule, staticBuildPathMap)
if err != nil {
- return errors.Annotate(err).Reason("failed to generate module YAML").Err()
+ return errors.Annotate(err, "failed to generate module YAML").Err()
}
appYAMLName := "module.yaml"
@@ -482,15 +474,14 @@
}
f := base.File(appYAMLName)
if err := f.GenerateYAML(w, appYAML); err != nil {
- return errors.Annotate(err).Reason("failed to generate %(filename)q file").
- D("filename", appYAMLName).Err()
+ return errors.Annotate(err, "failed to generate %q file", appYAMLName).Err()
}
s := f.String()
appYAMLPath = &s
// Cleanup our staging filesystem.
if err := root.CleanUp(); err != nil {
- return errors.Annotate(err).Reason("failed to cleanup component directory").Err()
+ return errors.Annotate(err, "failed to cleanup component directory").Err()
}
return nil
}
@@ -525,7 +516,7 @@
cwd(appPath)
x = addGoEnv(m.goPath, x)
if err := x.check(w); err != nil {
- return errors.Annotate(err).Reason("failed to deploy classic GAE module").Err()
+ return errors.Annotate(err, "failed to deploy classic GAE module").Err()
}
return nil
}
@@ -534,10 +525,10 @@
func (m *stagedGAEModule) localBuildGo(w *work, mainPkg string) error {
gt, err := w.goTool(m.goPath)
if err != nil {
- return errors.Annotate(err).Reason("failed to get Go tool").Err()
+ return errors.Annotate(err, "failed to get Go tool").Err()
}
if err := gt.build(w, "", mainPkg); err != nil {
- return errors.Annotate(err).Reason("failed to local build %(pkg)q").D("pkg", mainPkg).Err()
+ return errors.Annotate(err, "failed to local build %q", mainPkg).Err()
}
return nil
}
@@ -549,7 +540,7 @@
// Deploy Managed VM.
aedeploy, err := w.tools.aedeploy(m.goPath)
if err != nil {
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
}
gcloud, err := w.tools.gcloud(m.gaeDep.project.Name)
@@ -578,7 +569,7 @@
x := aedeploy.bootstrap(gcloud.exec(gcloudArgs[0], gcloudArgs[1:]...)).outputAt(logLevel).cwd(appDir)
if err := x.check(w); err != nil {
- return errors.Annotate(err).Reason("failed to deploy managed VM").Err()
+ return errors.Annotate(err, "failed to deploy managed VM").Err()
}
return nil
}
diff --git a/deploytool/cmd/luci_deploy/deploy_container_engine.go b/deploytool/cmd/luci_deploy/deploy_container_engine.go
index 614059f..1664552 100644
--- a/deploytool/cmd/luci_deploy/deploy_container_engine.go
+++ b/deploytool/cmd/luci_deploy/deploy_container_engine.go
@@ -119,7 +119,7 @@
podRoot, err := root.EnsureDirectory("pods")
if err != nil {
- return errors.Annotate(err).Reason("failed to create pods directory").Err()
+ return errors.Annotate(err, "failed to create pods directory").Err()
}
// Stage in parallel. We will stage all pods before we stage any containers,
@@ -135,8 +135,7 @@
var err error
if cluster.kubeCtx, err = getContainerEngineKubernetesContext(w, cluster.cluster); err != nil {
- return errors.Annotate(err).Reason("failed to get Kubernetes context for %(cluster)q").
- D("cluster", cluster.cluster.Name).Err()
+ return errors.Annotate(err, "failed to get Kubernetes context for %q", cluster.cluster.Name).Err()
}
}
return nil
@@ -149,8 +148,7 @@
name := pod.pod.comp.comp.Name
podDir, err := podRoot.EnsureDirectory(name)
if err != nil {
- return errors.Annotate(err).Reason("failed to create pod directory for %(pod)q").
- D("pod", name).Err()
+ return errors.Annotate(err, "failed to create pod directory for %q", name).Err()
}
return pod.stage(w, podDir, params)
@@ -164,7 +162,7 @@
// Now that pods are deployed, deploy our clusters.
clusterRoot, err := root.EnsureDirectory("clusters")
if err != nil {
- return errors.Annotate(err).Reason("failed to create clusters directory").Err()
+ return errors.Annotate(err, "failed to create clusters directory").Err()
}
return w.RunMulti(func(workC chan<- func() error) {
@@ -175,8 +173,7 @@
workC <- func() error {
clusterDir, err := clusterRoot.EnsureDirectory(cluster.cluster.Name)
if err != nil {
- return errors.Annotate(err).Reason("failed to create cluster directory for %(cluster)q").
- D("cluster", cluster.cluster.Name).Err()
+ return errors.Annotate(err, "failed to create cluster directory for %q", cluster.cluster.Name).Err()
}
return cluster.stage(w, clusterDir)
@@ -272,7 +269,7 @@
workC <- func() error {
stageDir, err := root.EnsureDirectory(string(bp.sp.pod.comp.comp.title))
if err != nil {
- return errors.Annotate(err).Reason("failed to create staging directory").Err()
+ return errors.Annotate(err, "failed to create staging directory").Err()
}
return bp.stage(w, stageDir)
@@ -327,7 +324,7 @@
deploymentYAML := root.File("deployment.yaml")
if err := deploymentYAML.GenerateYAML(w, depYAML); err != nil {
- return errors.Annotate(err).Reason("failed to generate deployment YAML").Err()
+ return errors.Annotate(err, "failed to generate deployment YAML").Err()
}
bp.deploymentYAMLPath = deploymentYAML.String()
return nil
@@ -336,7 +333,7 @@
func (bp *containerEngineBoundPod) commit(w *work) error {
kubectl, err := bp.c.kubectl(w)
if err != nil {
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
}
// Get the current deployment status for this pod.
@@ -362,7 +359,7 @@
"managedBy": v,
"deployment": bp.sp.deploymentName,
}.Errorf(w, "Current deployment is not managed.")
- return errors.Reason("unknown manager %(managedBy)q").D("managedBy", v).Err()
+ return errors.Reason("unknown manager %q", v).Err()
}
// Is the current deployment tagged at the current version?
@@ -374,8 +371,7 @@
switch {
case err != nil:
if !bp.c.gke.ignoreCurrentVersion {
- return errors.Annotate(err).Reason("failed to parse current version %(version)q").
- D("version", currentVersion).Err()
+ return errors.Annotate(err, "failed to parse current version %q", currentVersion).Err()
}
log.Fields{
@@ -406,13 +402,12 @@
"deployVersion": bp.sp.version,
}.Infof(w, "Deploying new pod configuration.")
if err := kubectl.exec("apply", "-f", bp.deploymentYAMLPath).check(w); err != nil {
- return errors.Annotate(err).Reason("failed to create new deployment configuration").Err()
+ return errors.Annotate(err, "failed to create new deployment configuration").Err()
}
return nil
default:
- return errors.Annotate(err).Reason("failed to get status for deployment %(deployment)q").
- D("deployment", bp.sp.deploymentName).Err()
+ return errors.Annotate(err, "failed to get status for deployment %q", bp.sp.deploymentName).Err()
}
}
@@ -449,7 +444,7 @@
var err error
sp.version, err = makeCloudProjectVersion(sp.cloudProject(), sp.pod.comp.source())
if err != nil {
- return errors.Annotate(err).Reason("failed to get cloud version").Err()
+ return errors.Annotate(err, "failed to get cloud version").Err()
}
}
@@ -484,10 +479,10 @@
// Construct a GOPATH for this module.
goPath, err := root.EnsureDirectory("gopath")
if err != nil {
- return errors.Annotate(err).Reason("failed to create GOPATH base").Err()
+ return errors.Annotate(err, "failed to create GOPATH base").Err()
}
if err := stageGoPath(w, comp, goPath); err != nil {
- return errors.Annotate(err).Reason("failed to stage GOPATH").Err()
+ return errors.Annotate(err, "failed to stage GOPATH").Err()
}
sp.goPath = []string{goPath.String()}
}
@@ -495,7 +490,7 @@
// Stage each of our containers.
containersDir, err := root.EnsureDirectory("containers")
if err != nil {
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
}
err = w.RunMulti(func(workC chan<- func() error) {
// Stage each component.
@@ -504,12 +499,11 @@
workC <- func() error {
containerDir, err := containersDir.EnsureDirectory(skc.Name)
if err != nil {
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
}
if err := skc.stage(w, containerDir); err != nil {
- return errors.Annotate(err).Reason("failed to stage container %(container)q").
- D("container", skc.Name).Err()
+ return errors.Annotate(err, "failed to stage container %q", skc.Name).Err()
}
return nil
}
@@ -520,7 +514,7 @@
}
if err := root.CleanUp(); err != nil {
- return errors.Annotate(err).Reason("failed to cleanup staging area").Err()
+ return errors.Annotate(err, "failed to cleanup staging area").Err()
}
return nil
}
@@ -577,10 +571,10 @@
// Build each Component.
buildDir, err := root.EnsureDirectory("build")
if err != nil {
- return errors.Annotate(err).Reason("failed to create build directory").Err()
+ return errors.Annotate(err, "failed to create build directory").Err()
}
if err := buildComponent(w, skc.pod.pod.comp, buildDir); err != nil {
- return errors.Annotate(err).Reason("failed to build component").Err()
+ return errors.Annotate(err, "failed to build component").Err()
}
switch skc.Type {
@@ -589,13 +583,13 @@
skc.buildFn = func(w *work) error {
path, err := skc.pod.pod.comp.buildPath(skc.GetBuild())
if err != nil {
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
}
return skc.buildGo(w, path)
}
default:
- return errors.Reason("unknown Kubernetes pod type %(type)T").D("type", skc.Type).Err()
+ return errors.Reason("unknown Kubernetes pod type %T", skc.Type).Err()
}
return nil
}
@@ -611,13 +605,13 @@
func (skc *stagedKubernetesContainer) buildGo(w *work, entryPath string) error {
gcloud, err := w.tools.gcloud(skc.pod.cloudProject().Name)
if err != nil {
- return errors.Annotate(err).Reason("could not get gcloud tool").Err()
+ return errors.Annotate(err, "could not get gcloud tool").Err()
}
// Use "aedeploy" to gather GOPATH and build against our root.
aedeploy, err := w.tools.aedeploy(skc.pod.goPath)
if err != nil {
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
}
x := gcloud.exec("docker", "--", "build", "-t", skc.image, ".")
@@ -627,12 +621,11 @@
func (skc *stagedKubernetesContainer) push(w *work) error {
gcloud, err := w.tools.gcloud(skc.pod.cloudProject().Name)
if err != nil {
- return errors.Annotate(err).Reason("could not get gcloud tool").Err()
+ return errors.Annotate(err, "could not get gcloud tool").Err()
}
if err := gcloud.exec("docker", "--", "push", skc.image).check(w); err != nil {
- return errors.Annotate(err).Reason("failed to push Docker image %(image)q").
- D("image", skc.image).Err()
+ return errors.Annotate(err, "failed to push Docker image %q", skc.image).Err()
}
return nil
}
@@ -645,18 +638,18 @@
kubectl, err := w.tools.kubectl(kubeCtx)
if err != nil {
- return "", errors.Annotate(err).Err()
+ return "", errors.Annotate(err, "").Err()
}
// Check if the context is already installed in our Kubernetes configuration.
switch has, err := kubectl.hasContext(w); {
case err != nil:
- return "", errors.Annotate(err).Reason("failed to check for Kubernetes context").Err()
+ return "", errors.Annotate(err, "failed to check for Kubernetes context").Err()
case !has:
gcloud, err := w.tools.gcloud(cluster.cloudProject.Name)
if err != nil {
- return "", errors.Annotate(err).Err()
+ return "", errors.Annotate(err, "").Err()
}
// The context isn't cached, we will fetch it via:
@@ -666,13 +659,13 @@
"get-credentials", cluster.Name,
"--zone", cluster.Zone)
if err := x.check(w); err != nil {
- return "", errors.Annotate(err).Reason("failed to get cluster credentials").Err()
+ return "", errors.Annotate(err, "failed to get cluster credentials").Err()
}
switch has, err = kubectl.hasContext(w); {
case err != nil:
- return "", errors.Annotate(err).Reason("failed to confirm Kubernetes context").Err()
+ return "", errors.Annotate(err, "failed to confirm Kubernetes context").Err()
case !has:
- return "", errors.Reason("context %(context)q missing after fetching credentials").D("context", kubeCtx).Err()
+ return "", errors.Reason("context %q missing after fetching credentials", kubeCtx).Err()
}
}
return kubeCtx, nil
diff --git a/deploytool/cmd/luci_deploy/kubernetes.go b/deploytool/cmd/luci_deploy/kubernetes.go
index d09e8a7..1ed1bb2 100644
--- a/deploytool/cmd/luci_deploy/kubernetes.go
+++ b/deploytool/cmd/luci_deploy/kubernetes.go
@@ -439,7 +439,7 @@
default:
if err := yaml.Unmarshal(x.stdout.Bytes(), obj); err != nil {
- return errors.Annotate(err).Reason("failed to unmarshal YAML %(type)T").D("type", obj).Err()
+ return errors.Annotate(err, "failed to unmarshal YAML %T", obj).Err()
}
return nil
}
diff --git a/deploytool/cmd/luci_deploy/layout.go b/deploytool/cmd/luci_deploy/layout.go
index 5b8bcf4..20d673a 100644
--- a/deploytool/cmd/luci_deploy/layout.go
+++ b/deploytool/cmd/luci_deploy/layout.go
@@ -42,7 +42,7 @@
// within the source root (e.g., "relpath" is prepended to it).
func (s *layoutSource) pathTo(p, relpath string) string {
if s.Relpath == "" {
- panic(errors.Reason("source %(source)q is not checked out").D("source", s).Err())
+ panic(errors.Reason("source %q is not checked out", s).Err())
}
// If this is absolute, take it relative to source root.
@@ -127,7 +127,7 @@
// left-to-right manner.
func (d *layoutDeployment) substituteParams(vp *string) error {
if err := substitute(vp, d.Parameter); err != nil {
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
}
return nil
}
@@ -179,20 +179,19 @@
if path, ok := comp.buildPathMap[bp]; ok {
return path, nil
}
- return "", errors.Reason("no build path resolved for: %(bp)+v").D("bp", bp, "%+v").Err()
+ return "", errors.Reason("no build path resolved for: %+v", bp).Err()
}
func (comp *layoutDeploymentComponent) loadSourceComponent(reg componentRegistrar) error {
if err := unmarshalTextProtobuf(comp.source().pathTo(comp.comp.Path, ""), &comp.Component); err != nil {
- return errors.Annotate(err).Reason("failed to load source component %(component)q").D("component", comp).Err()
+ return errors.Annotate(err, "failed to load source component %q", comp).Err()
}
// Referenced build paths.
for i, p := range comp.BuildPath {
var msg deploy.Component_Build
if err := unmarshalTextProtobuf(comp.pathTo(p), &msg); err != nil {
- return errors.Annotate(err).Reason("failed to load component Build #%(index)d from [%(path)s]").
- D("index", i).D("path", p).Err()
+ return errors.Annotate(err, "failed to load component Build #%d from [%s]", i, p).Err()
}
comp.Build = append(comp.Build, &msg)
}
@@ -207,8 +206,7 @@
// - All referenced path parameters will be loaded and appended onto their
// non-path members.
if dep.cloudProject == nil {
- return errors.Reason("AppEngine module %(comp)q requires a cloud project").
- D("comp", comp).Err()
+ return errors.Reason("AppEngine module %q requires a cloud project", comp).Err()
}
aem := t.AppengineModule
@@ -225,8 +223,7 @@
for i, p := range aem.HandlerPath {
var msg deploy.AppEngineModule_HandlerSet
if err := unmarshalTextProtobuf(comp.pathTo(p), &msg); err != nil {
- return errors.Annotate(err).Reason("failed to load HandlerSet #%(index)d for %(component)q").
- D("index", i).D("component", comp).Err()
+ return errors.Annotate(err, "failed to load HandlerSet #%d for %q", i, comp).Err()
}
module.Handlers.Handler = append(module.Handlers.Handler, msg.Handler...)
}
@@ -237,8 +234,7 @@
path := module.comp.pathTo(p)
res, err := loadIndexYAMLResource(path)
if err != nil {
- return errors.Annotate(err).Reason("failed to load 'index.yaml' from [%(path)s]").
- D("path", path).Err()
+ return errors.Annotate(err, "failed to load 'index.yaml' from [%s]", path).Err()
}
dep.cloudProject.appendResources(res, &module)
}
@@ -250,14 +246,14 @@
for i, p := range module.ResourcePath {
if err := comp.dep.substituteParams(&p); err != nil {
- return errors.Annotate(err).Reason("failed to substitute parameters for resource path").
- D("path", p).Err()
+ return errors.Annotate(err, "failed to substitute parameters for resource path").
+ InternalReason("path(%s)", p).Err()
}
var res deploy.AppEngineResources
if err := unmarshalTextProtobuf(comp.pathTo(p), &res); err != nil {
- return errors.Annotate(err).Reason("failed to load Resources #%(index)d for %(component)").
- D("index", i).D("path", p).D("component", comp).Err()
+ return errors.Annotate(err, "failed to load Resources #%d for %q", i, comp).
+ InternalReason("path(%s)", p).Err()
}
dep.cloudProject.appendResources(&res, &module)
}
@@ -270,8 +266,7 @@
case *deploy.Component_GkePod:
if len(comp.gkePods) == 0 {
- return errors.Reason("GKE Container %(comp)q is not bound to a GKE cluster").
- D("comp", comp.String()).Err()
+ return errors.Reason("GKE Container %q is not bound to a GKE cluster", comp).Err()
}
comp.gkePod = &layoutDeploymentGKEPod{
@@ -289,7 +284,7 @@
if len(invalidLabels) > 0 {
sort.Strings(invalidLabels)
return errors.Reason("user-supplied labels may not use deploytool prefix").
- D("labels", invalidLabels).Err()
+ InternalReason("labels(%v)", invalidLabels).Err()
}
for _, bp := range comp.gkePods {
@@ -319,7 +314,7 @@
if bp.DirKey != "" {
dir, ok := comp.buildDirs[bp.DirKey]
if !ok {
- return errors.Reason("Invalid `dir_key` value: %(dirKey)q").D("dirKey", bp.DirKey).Err()
+ return errors.Reason("Invalid `dir_key` value: %q", bp.DirKey).Err()
}
resolved = deployToNative(dir, bp.Path)
} else {
@@ -349,16 +344,16 @@
Build: &deploy.BuildPath{Path: bd.Path},
}
if err := resolveBuildPath(sf.GetBuild()); err != nil {
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
}
case *deploy.AppEngineModule_Handler_StaticFiles_Build:
if err := resolveBuildPath(bd.Build); err != nil {
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
}
default:
- return errors.Reason("unknown `base_dir` type %(type)T").D("type", bd).Err()
+ return errors.Reason("unknown `base_dir` type %T", bd).Err()
}
case *deploy.AppEngineModule_Handler_StaticDir:
@@ -368,12 +363,12 @@
StaticBuildDir: &deploy.BuildPath{Path: c.StaticDir},
}
if err := resolveBuildPath(handler.GetStaticBuildDir()); err != nil {
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
}
case *deploy.AppEngineModule_Handler_StaticBuildDir:
if err := resolveBuildPath(c.StaticBuildDir); err != nil {
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
}
}
}
@@ -388,16 +383,16 @@
Build: &deploy.BuildPath{Path: df.Path},
}
if err := resolveBuildPath(container.GetBuild()); err != nil {
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
}
case *deploy.KubernetesPod_Container_Build:
if err := resolveBuildPath(df.Build); err != nil {
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
}
default:
- return errors.Reason("unknown `dockerfile` type %(type)T").D("type", df).Err()
+ return errors.Reason("unknown `dockerfile` type %T", df).Err()
}
}
}
@@ -529,7 +524,7 @@
func (l *deployLayout) workingFilesystem() (*managedfs.Filesystem, error) {
fs, err := managedfs.New(l.WorkingPath)
if err != nil {
- return nil, errors.Annotate(err).Err()
+ return nil, errors.Annotate(err, "").Err()
}
return fs, nil
}
@@ -543,16 +538,16 @@
dep := l.deployments[deployment]
if dep == nil {
- return nil, nil, errors.Reason("unknown Deployment %(dep)q").
- D("value", v).D("dep", deployment).Err()
+ return nil, nil, errors.Reason("unknown Deployment %q", deployment).
+ InternalReason("value(%s)", v).Err()
}
// If a component was specified, only add that component.
if component != "" {
comp := dep.components[component]
if comp == nil {
- return nil, nil, errors.Reason("unknown Deployment Component %(value)q").
- D("value", v).D("dep", deployment).D("comp", component).Err()
+ return nil, nil, errors.Reason("unknown Deployment Component %q", v).
+ InternalReason("dep(%s)/comp(%s)", deployment, component).Err()
}
return dep, comp, nil
}
@@ -565,7 +560,7 @@
matched, err := filepath.Match(m, dep.String())
if err != nil {
- return errors.Annotate(err).Reason("failed to match %(pattern)q").D("pattern", m).Err()
+ return errors.Annotate(err, "failed to match %q", m).Err()
}
if matched {
// Matches entire deployment.
@@ -579,7 +574,7 @@
matched, err := filepath.Match(m, comp.String())
if err != nil {
- return errors.Annotate(err).Reason("failed to match %(pattern)q").D("pattern", m).Err()
+ return errors.Annotate(err, "failed to match %q", m).Err()
}
if matched {
cb(dep, comp)
@@ -608,7 +603,7 @@
// Load the user config, if available.
if err := loadUserConfig(c, &l.user); err != nil {
- return errors.Annotate(err).Reason("failed to load user config").Err()
+ return errors.Annotate(err, "failed to load user config").Err()
}
if len(l.user.SourceOverride) > 0 {
l.userSourceOverrides = make(map[string]*deploy.Source, len(l.user.SourceOverride))
@@ -639,8 +634,7 @@
absWorkingPath, err := filepath.Abs(l.WorkingPath)
if err != nil {
- return errors.Annotate(err).Reason("failed to resolve absolute path for %(path)q").
- D("path", l.WorkingPath).Err()
+ return errors.Annotate(err, "failed to resolve absolute path for %q", l.WorkingPath).Err()
}
l.WorkingPath = absWorkingPath
return nil
@@ -649,7 +643,7 @@
func (l *deployLayout) initFrozenCheckout(c context.Context) (*deploy.FrozenLayout, error) {
fis, err := ioutil.ReadDir(l.SourcesPath)
if err != nil {
- return nil, errors.Annotate(err).Reason("failed to read directory").Err()
+ return nil, errors.Annotate(err, "failed to read directory").Err()
}
// Build internal and frozen layout in parallel.
@@ -697,7 +691,7 @@
t, err := titleFromConfigPath(name)
if err != nil {
- return errors.Annotate(err).Reason("invalid source title").Err()
+ return errors.Annotate(err, "invalid source title").Err()
}
src := deploy.FrozenLayout_Source{
@@ -707,8 +701,7 @@
return nil
})
if err != nil {
- return nil, errors.Annotate(err).Reason("failed to load source group %(name)q from [%(path)s]").
- D("name", name).D("path", path).Err()
+ return nil, errors.Annotate(err, "failed to load source group %q from [%s]", name, path).Err()
}
frozen.SourceGroup[string(name)] = &sg
@@ -721,7 +714,7 @@
// Load the frozen configuration file from disk.
frozen, err := checkoutFrozen(l)
if err != nil {
- return errors.Annotate(err).Reason("failed to load frozen checkout").Err()
+ return errors.Annotate(err, "failed to load frozen checkout").Err()
}
// Load our source groups and sources.
@@ -748,12 +741,10 @@
// Build our internally-connected structures from the frozen layout.
if err := l.loadApps(c); err != nil {
- return errors.Annotate(err).Reason("failed to load applications from [%(path)s]").
- D("path", l.ApplicationsPath).Err()
+ return errors.Annotate(err, "failed to load applications from [%s]", l.ApplicationsPath).Err()
}
if err := l.loadDeployments(c); err != nil {
- return errors.Annotate(err).Reason("failed to load deployments from [%(path)s]").
- D("path", l.DeploymentsPath).Err()
+ return errors.Annotate(err, "failed to load deployments from [%s]", l.DeploymentsPath).Err()
}
return nil
}
@@ -761,7 +752,7 @@
func (l *deployLayout) loadApps(c context.Context) error {
fis, err := ioutil.ReadDir(l.ApplicationsPath)
if err != nil {
- return errors.Annotate(err).Reason("failed to read directory").Err()
+ return errors.Annotate(err, "failed to read directory").Err()
}
apps := make(map[title]*deploy.Application, len(fis))
var appBase deploy.Application
@@ -770,7 +761,7 @@
t, err := titleFromConfigPath(name)
if err != nil {
- return errors.Annotate(err).Reason("invalid application title").Err()
+ return errors.Annotate(err, "invalid application title").Err()
}
apps[t] = &cpy
@@ -793,8 +784,7 @@
for _, comp := range proj.Component {
compT := title(comp.Name)
if err := compT.validate(); err != nil {
- return errors.Annotate(err).Reason("application %(app)q component %(component)q is not a valid component title").
- D("app", t).D("component", comp.Name).Err()
+ return errors.Annotate(err, "application %q component %q is not a valid component title", t, comp.Name).Err()
}
proj.components[compT] = &layoutAppComponent{
Application_Component: comp,
@@ -811,7 +801,7 @@
func (l *deployLayout) loadDeployments(c context.Context) error {
fis, err := ioutil.ReadDir(l.DeploymentsPath)
if err != nil {
- return errors.Annotate(err).Reason("failed to read directory").Err()
+ return errors.Annotate(err, "failed to read directory").Err()
}
deployments := make(map[title]*deploy.Deployment, len(fis))
var deploymentBase deploy.Deployment
@@ -820,7 +810,7 @@
t, err := titleFromConfigPath(name)
if err != nil {
- return errors.Annotate(err).Reason("invalid deployment title").Err()
+ return errors.Annotate(err, "invalid deployment title").Err()
}
deployments[t] = &cpy
@@ -834,8 +824,7 @@
for t, d := range deployments {
dep, err := l.loadDeployment(t, d)
if err != nil {
- return errors.Annotate(err).Reason("failed to load deployment (%(deployment)q)").
- D("deployment", t).Err()
+ return errors.Annotate(err, "failed to load deployment (%q)", t).Err()
}
l.deployments[t] = dep
l.deploymentNames = append(l.deploymentNames, dep.title)
@@ -852,14 +841,13 @@
sg: l.sourceGroups[title(d.SourceGroup)],
}
if dep.sg == nil {
- return nil, errors.Reason("unknown source group %(sourceGroup)q").
- D("sourceGroup", d.SourceGroup).Err()
+ return nil, errors.Reason("unknown source group %q", d.SourceGroup).Err()
}
// Resolve our application.
dep.app = l.apps[title(dep.Application)]
if dep.app == nil {
- return nil, errors.Reason("unknown application %(app)q").D("app", dep.Application).Err()
+ return nil, errors.Reason("unknown application %q", dep.Application).Err()
}
// Initialize our Components. Their protobufs cannot not be loaded until
@@ -873,14 +861,12 @@
sources: []*layoutSource{dep.sg.sources[title(projComp.Source)]},
}
if comp.sources[0] == nil {
- return nil, errors.Reason("application references non-existent source %(source)q").
- D("source", projComp.Source).Err()
+ return nil, errors.Reason("application references non-existent source %q", projComp.Source).Err()
}
for _, os := range projComp.OtherSource {
src := dep.sg.sources[title(os)]
if src == nil {
- return nil, errors.Reason("application references non-existent other source %(source)q").
- D("source", os).Err()
+ return nil, errors.Reason("application references non-existent other source %q", os).Err()
}
comp.sources = append(comp.sources, src)
}
@@ -899,8 +885,7 @@
l.cloudProjects = make(map[string]*layoutDeploymentCloudProject)
}
if cur, ok := l.cloudProjects[cp.Name]; ok {
- return nil, errors.Reason("cloud project %(name)q defined by both %(curDep)q and %(thisDep)q").
- D("name", cp.Name).D("curDep", cur.dep.title).D("thisDep", dep.title).Err()
+ return nil, errors.Reason("cloud project %q defined by both %q and %q", cp.Name, cur.dep.title, dep.title).Err()
}
l.cloudProjects[cp.Name] = &cp
@@ -917,12 +902,10 @@
comp := dep.components[title(b.Name)]
switch {
case comp == nil:
- return nil, errors.Reason("unknown component %(comp)q for cluster %(name)q").
- D("comp", b.Name).D("name", gke.Name).Err()
+ return nil, errors.Reason("unknown component %q for cluster %q", b.Name, gke.Name).Err()
case b.Replicas <= 0:
- return nil, errors.Reason("GKE component %(comp)q must have at least 1 replica").
- D("comp", b.Name).Err()
+ return nil, errors.Reason("GKE component %q must have at least 1 replica", b.Name).Err()
}
bp := &layoutDeploymentGKEPodBinding{
@@ -975,16 +958,14 @@
break
default:
- return "", errors.Annotate(err).Reason("failed to state %(path)q").
- D("path", path).Err()
+ return "", errors.Annotate(err, "failed to state %q", path).Err()
}
// Walk up one directory.
oldDir := dir
dir, _ = filepath.Split(dir)
if oldDir == dir {
- return "", errors.Reason("could not find %(filename)q starting from %(dir)q").
- D("filename", filename).D("dir", dir).Err()
+ return "", errors.Reason("could not find %q starting from %q", filename, dir).Err()
}
}
}
diff --git a/deploytool/cmd/luci_deploy/manage.go b/deploytool/cmd/luci_deploy/manage.go
index f6fba78..b6f01de 100644
--- a/deploytool/cmd/luci_deploy/manage.go
+++ b/deploytool/cmd/luci_deploy/manage.go
@@ -86,7 +86,7 @@
return mApp.dp.initialize(w, &a.layout)
})
if err != nil {
- return nil, errors.Annotate(err).Reason("failed to initialize deployment plan").Err()
+ return nil, errors.Annotate(err, "failed to initialize deployment plan").Err()
}
switch comp.GetComponent().(type) {
@@ -136,7 +136,7 @@
return mApp.dp.initialize(w, &a.layout)
})
if err != nil {
- return nil, errors.Annotate(err).Reason("failed to initialize deployment plan").Err()
+ return nil, errors.Annotate(err, "failed to initialize deployment plan").Err()
}
if cp := dep.cloudProject; cp != nil {
@@ -182,12 +182,12 @@
err = a.runWork(c, func(w *work) error {
kubeCtx, err := getContainerEngineKubernetesContext(w, bp.cluster)
if err != nil {
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
}
kubectl, err := w.tools.kubectl(kubeCtx)
if err != nil {
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
}
rv, err = kubectl.exec(args...).forwardOutput().run(w)
@@ -252,11 +252,11 @@
cloudProjectName := bp.pod.comp.dep.cloudProject.Name
gcloud, err := w.tools.gcloud(cloudProjectName)
if err != nil {
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
}
if rv, err = gcloud.exec(gcloudArgs[0], gcloudArgs[1:]...).run(w); err != nil {
- return errors.Annotate(err).Reason("failed to run 'gcloud' command").Err()
+ return errors.Annotate(err, "failed to run 'gcloud' command").Err()
}
return nil
})
@@ -275,9 +275,7 @@
case cluster != "":
cluster := comp.dep.cloudProject.gkeClusters[cluster]
if cluster == nil {
- return nil, errors.Reason("invalid GKE cluster name: %(name)q").
- D("name", cluster).
- Err()
+ return nil, errors.Reason("invalid GKE cluster name: %q", cluster).Err()
}
for _, gkeBP := range comp.gkePods {
if gkeBP.cluster == cluster {
@@ -299,8 +297,7 @@
}
return nil, errors.Reason("the Kubernetes pod is bound to multiple clusters. Specify one with -cluster").
- D("clusters", clusters).
- Err()
+ InternalReason("clusters(%v)", clusters).Err()
}
if bp == nil {
return nil, errors.New("Could not identify cluster for pod.")
diff --git a/deploytool/cmd/luci_deploy/param.go b/deploytool/cmd/luci_deploy/param.go
index 4216122..e4e53e2 100644
--- a/deploytool/cmd/luci_deploy/param.go
+++ b/deploytool/cmd/luci_deploy/param.go
@@ -40,7 +40,7 @@
} else {
// panic to immediately stop matching. This will be caught at the top of
// this function.
- return errors.Reason("undefined parameter %(key)q").D("key", key).Err()
+ return errors.Reason("undefined parameter %q", key).Err()
}
}
diff --git a/deploytool/cmd/luci_deploy/path.go b/deploytool/cmd/luci_deploy/path.go
index d732497..ef427e6 100644
--- a/deploytool/cmd/luci_deploy/path.go
+++ b/deploytool/cmd/luci_deploy/path.go
@@ -58,7 +58,7 @@
// Create a temporary directory.
tdir, err := ioutil.TempDir("", "luci_deploytool")
if err != nil {
- return errors.Annotate(err).Reason("failed to create tempdir").Err()
+ return errors.Annotate(err, "failed to create tempdir").Err()
}
defer os.RemoveAll(tdir)
diff --git a/deploytool/cmd/luci_deploy/staging.go b/deploytool/cmd/luci_deploy/staging.go
index f35c96e..de22190 100644
--- a/deploytool/cmd/luci_deploy/staging.go
+++ b/deploytool/cmd/luci_deploy/staging.go
@@ -36,8 +36,7 @@
for _, gopath := range src.InitResult.GoPath {
// Make sure our Go package isn't a directory.
if _, ok := dirs[gopath.GoPackage]; ok {
- return errors.Reason("GOPATH %(package)q is both a package and directory").
- D("package", gopath.GoPackage).Err()
+ return errors.Reason("GOPATH %q is both a package and directory", gopath.GoPackage).Err()
}
// Check intermediate paths to make sure there isn't a deployment
@@ -45,8 +44,7 @@
pkgParts := splitGoPackage(gopath.GoPackage)
for _, parentPkg := range pkgParts[:len(pkgParts)-1] {
if _, ok := build[parentPkg]; ok {
- return errors.Reason("GOPATH %(package)q is both a package and directory").
- D("package", parentPkg).Err()
+ return errors.Reason("GOPATH %q is both a package and directory", parentPkg).Err()
}
dirs[parentPkg] = struct{}{}
}
@@ -70,13 +68,12 @@
var err error
d, err = d.EnsureDirectory(comp)
if err != nil {
- return errors.Annotate(err).Reason("could not create GOPATH parent directory [%(path)s]").
- D("path", d).Err()
+ return errors.Annotate(err, "could not create GOPATH parent directory [%s]", d).Err()
}
}
link := d.File(pkgComponents[len(pkgComponents)-1])
if err := link.SymlinkFrom(src, true); err != nil {
- return errors.Annotate(err).Reason("failed to create GOPATH link").Err()
+ return errors.Annotate(err, "failed to create GOPATH link").Err()
}
}
return nil
diff --git a/deploytool/cmd/luci_deploy/title.go b/deploytool/cmd/luci_deploy/title.go
index f2e77db..082a1b3 100644
--- a/deploytool/cmd/luci_deploy/title.go
+++ b/deploytool/cmd/luci_deploy/title.go
@@ -21,8 +21,7 @@
idx := 0
for _, r := range t {
if !(unicode.IsLetter(r) || unicode.IsNumber(r) || r == '-') {
- return errors.Reason("character at %(pos)d (%(char)c) is not permitted in a title").
- D("pos", idx).D("char", r).Err()
+ return errors.Reason("character at %d (%c) is not permitted in a title", idx, r).Err()
}
idx++
}
diff --git a/deploytool/cmd/luci_deploy/tools.go b/deploytool/cmd/luci_deploy/tools.go
index 34cb3dc..29fdbfd 100644
--- a/deploytool/cmd/luci_deploy/tools.go
+++ b/deploytool/cmd/luci_deploy/tools.go
@@ -48,7 +48,7 @@
if path == "" {
// Lookup was attempted, but tool could not be found.
- return "", errors.Reason("tool %(toolName)q is not available").D("toolName", command).Err()
+ return "", errors.Reason("tool %q is not available", command).Err()
}
return path, nil
}
@@ -173,7 +173,8 @@
output := strings.TrimSpace(x.stdout.String())
v, err := strconv.Atoi(output)
if err != nil {
- return 0, errors.Annotate(err).Reason("failed to parse rev-list count").D("output", output).Err()
+ return 0, errors.Annotate(err, "failed to parse rev-list count").
+ InternalReason("output(%s)", output).Err()
}
return v, nil
}
diff --git a/deploytool/cmd/luci_deploy/util.go b/deploytool/cmd/luci_deploy/util.go
index 1db382b..468875f 100644
--- a/deploytool/cmd/luci_deploy/util.go
+++ b/deploytool/cmd/luci_deploy/util.go
@@ -22,8 +22,7 @@
switch {
case err == nil:
if err := proto.UnmarshalText(string(data), msg); err != nil {
- return errors.Annotate(err).Reason("failed to unmarshal %(type)T from [%(path)s]").
- D("type", msg).D("path", path).Err()
+ return errors.Annotate(err, "failed to unmarshal %T from [%s]", msg, path).Err()
}
return nil
@@ -32,7 +31,7 @@
return err
default:
- return errors.Annotate(err).Reason("failed to read data from [%(path)s]").D("path", path).Err()
+ return errors.Annotate(err, "failed to read data from [%s]", path).Err()
}
}
@@ -44,10 +43,10 @@
}
if err := unmarshalTextProtobuf(filepath.Join(base, name), msg); err != nil {
- return errors.Annotate(err).Reason("failed to unmarshal file [%(name)s]").D("name", name).Err()
+ return errors.Annotate(err, "failed to unmarshal file [%s]", name).Err()
}
if err := cb(name); err != nil {
- return errors.Annotate(err).Reason("failed to process file [%(name)s]").D("name", name).Err()
+ return errors.Annotate(err, "failed to process file [%s]", name).Err()
}
}
return nil
@@ -56,7 +55,7 @@
func logError(c context.Context, err error, f string, args ...interface{}) {
log.WithError(err).Errorf(c, f, args...)
if log.IsLogging(c, log.Debug) {
- log.Debugf(c, "Error stack:\n%s", strings.Join(errors.RenderStack(err).ToLines(), "\n"))
+ log.Debugf(c, "Error stack:\n%s", strings.Join(errors.RenderStack(err), "\n"))
}
}
diff --git a/deploytool/cmd/luci_deploy/version.go b/deploytool/cmd/luci_deploy/version.go
index 88ea383..8aed5dc 100644
--- a/deploytool/cmd/luci_deploy/version.go
+++ b/deploytool/cmd/luci_deploy/version.go
@@ -51,14 +51,14 @@
if src.sg.Tainted {
username, err := b.getCurrentUser()
if err != nil {
- return nil, errors.Annotate(err).Reason("could not get tained user").Err()
+ return nil, errors.Annotate(err, "could not get tained user").Err()
}
cpv.taintedUser = cloudVersionStringNormalize(username)
}
return &cpv, nil
default:
- return nil, errors.Reason("unknown version scheme %(scheme)v").D("scheme", vs).Err()
+ return nil, errors.Reason("unknown version scheme %v", vs).Err()
}
}
@@ -70,7 +70,7 @@
// Default "currentUser" function uses "os.User".
user, err := user.Current()
if err != nil {
- return "", errors.Annotate(err).Reason("could not get tained user").Err()
+ return "", errors.Annotate(err, "could not get tained user").Err()
}
return user.Username, nil
}
@@ -95,12 +95,11 @@
return &cpv, nil
default:
- return nil, errors.Reason("bad version %(version)q for scheme %(scheme)T").
- D("version", v).D("scheme", vs).Err()
+ return nil, errors.Reason("bad version %q for scheme %T", v, vs).Err()
}
default:
- return nil, errors.Reason("unknown version scheme %(scheme)T").D("scheme", vs).Err()
+ return nil, errors.Reason("unknown version scheme %T", vs).Err()
}
}
diff --git a/deploytool/cmd/luci_deploy/work.go b/deploytool/cmd/luci_deploy/work.go
index ea261eb..45fcf8c 100644
--- a/deploytool/cmd/luci_deploy/work.go
+++ b/deploytool/cmd/luci_deploy/work.go
@@ -127,14 +127,14 @@
// error without conflicting.
stdoutPipe, err := cmd.StdoutPipe()
if err != nil {
- return -1, errors.Annotate(err).Reason("failed to create STDOUT pipe").Err()
+ return -1, errors.Annotate(err, "failed to create STDOUT pipe").Err()
}
stdoutPipe = &closeOnceReader{ReadCloser: stdoutPipe}
defer stdoutPipe.Close()
stderrPipe, err := cmd.StderrPipe()
if err != nil {
- return -1, errors.Annotate(err).Reason("failed to create STDERR pipe").Err()
+ return -1, errors.Annotate(err, "failed to create STDERR pipe").Err()
}
stderrPipe = &closeOnceReader{ReadCloser: stderrPipe}
defer stderrPipe.Close()
@@ -207,8 +207,8 @@
"cwd": x.workdir,
}.Debugf(c, "Running command: %s %s.", x.command, x.args)
if err := cmd.Start(); err != nil {
- return -1, errors.Annotate(err).Reason("failed to start command").
- D("command", x.command).D("args", x.args).D("cwd", x.workdir).Err()
+ return -1, errors.Annotate(err, "failed to start command").
+ InternalReason("command(%s)/args(%v)/cwd(%s)", x.command, x.args, x.workdir).Err()
}
// Wait for our stream processing to finish.
@@ -222,8 +222,8 @@
return rc, nil
}
- return -1, errors.Annotate(err).Reason("failed to wait for command").
- D("command", x.command).D("args", x.args).D("cwd", x.workdir).Err()
+ return -1, errors.Annotate(err, "failed to wait for command").
+ InternalReason("command(%s)/args(%v)/cwd(%s)", x.command, x.args, x.workdir).Err()
}
log.Debugf(c, "Command completed with zero return code: %s %s", x.command, x.args)
@@ -233,7 +233,7 @@
func (x *workExecutor) check(c context.Context) error {
switch rc, err := x.run(c); {
case err != nil:
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
case rc != 0:
log.Fields{
@@ -243,8 +243,8 @@
"cwd": x.workdir,
}.Errorf(c, "Command failed with error return code.\nSTDOUT:\n%s\n\nSTDERR:\n%s",
x.stdout.String(), x.stderr.String())
- return errors.Reason("process exited with return code: %(returnCode)d").
- D("command", x.command).D("args", x.args).D("cwd", x.workdir).D("returnCode", rc).Err()
+ return errors.Reason("process exited with return code: %d", rc).
+ InternalReason("command(%s)/args(%v)/cwd(%s)", x.command, x.args, x.workdir).Err()
default:
return nil
@@ -289,7 +289,7 @@
amt, err = w.base.Write(d)
if amt > 0 {
if _, ierr := w.tee.Write(d[:amt]); ierr != nil {
- panic(errors.Annotate(ierr).Reason("failed to write to tee writer").Err())
+ panic(errors.Annotate(ierr, "failed to write to tee writer").Err())
}
}
return
diff --git a/deploytool/managedfs/filesystem.go b/deploytool/managedfs/filesystem.go
index e03ccc4..5256436 100644
--- a/deploytool/managedfs/filesystem.go
+++ b/deploytool/managedfs/filesystem.go
@@ -64,7 +64,7 @@
func New(rootDir string) (*Filesystem, error) {
rootDir = filepath.Clean(rootDir)
if err := ensureDirectory(rootDir); err != nil {
- return nil, errors.Annotate(err).Reason("failed to create root directory").Err()
+ return nil, errors.Annotate(err, "failed to create root directory").Err()
}
fs := Filesystem{
rootDir: rootDir,
@@ -115,14 +115,13 @@
// that targpath is under the Filesystem root.
func (d *Dir) RelPathFrom(targpath string) (string, error) {
if !isSubpath(d.fs.rootDir, targpath) {
- return "", errors.Reason("[%(path)s] is not a subpath of [%(root)s]").
- D("path", targpath).D("root", d.fs.rootDir).Err()
+ return "", errors.Reason("[%s] is not a subpath of [%s]", targpath, d.fs.rootDir).Err()
}
rel, err := filepath.Rel(d.String(), targpath)
if err != nil {
- return "", errors.Annotate(err).Reason("could not calculate relative path from [%(dir)s] to [%(path)s]").
- D("dir", d.String()).D("path", targpath).Err()
+ return "", errors.Annotate(err, "could not calculate relative path from [%s] to [%s]",
+ d.String(), targpath).Err()
}
return rel, nil
}
@@ -187,8 +186,7 @@
// If the described directory doesn't exist, it will be created.
func (d *Dir) EnsureDirectory(elem string, elems ...string) (*Dir, error) {
if !isValidSinglePathComponent(elem) {
- return nil, errors.Reason("invalid path component #0: %(comp)q").
- D("comp", elem).Err()
+ return nil, errors.Reason("invalid path component #0: %q", elem).Err()
}
// No element may have a path separator in it.
@@ -197,8 +195,7 @@
components = append(components, elem)
for i, comp := range elems {
if !isValidSinglePathComponent(comp) {
- return nil, errors.Reason("invalid path component #%(index)d: %(comp)q").
- D("index", i+1).D("comp", comp).Err()
+ return nil, errors.Reason("invalid path component #%d: %q", i+1, comp).Err()
}
components = append(components, comp)
}
@@ -206,7 +203,7 @@
// Make the full subdirectory path.
fullPath := filepath.Join(components...)
if err := ensureDirectory(fullPath); err != nil {
- return nil, errors.Annotate(err).Reason("failed to create directory [%(path)s]").D("path", fullPath).Err()
+ return nil, errors.Annotate(err, "failed to create directory [%s]", fullPath).Err()
}
// Return the last managed directory node.
@@ -217,7 +214,7 @@
func (d *Dir) ShallowSymlinkFrom(dir string, rel bool) error {
fis, err := ioutil.ReadDir(dir)
if err != nil {
- return errors.Annotate(err).Reason("failed to read directory [%(path)s]").D("path", dir).Err()
+ return errors.Annotate(err, "failed to read directory [%s]", dir).Err()
}
for _, fi := range fis {
@@ -237,7 +234,7 @@
// File creates a new managed File immediately within d.
func (d *Dir) File(name string) *File {
if !isValidSinglePathComponent(name) {
- panic(errors.Reason("invalid path component: %(name)q").D("name", name).Err())
+ panic(errors.Reason("invalid path component: %q", name).Err())
}
// Register this file with its managed directory.
@@ -291,7 +288,7 @@
// List the contents of this directory.
fis, err := ioutil.ReadDir(d.String())
if err != nil {
- return errors.Annotate(err).Reason("failed to read directory %(dir)q").D("dir", d.String()).Err()
+ return errors.Annotate(err, "failed to read directory %q", d.String()).Err()
}
for _, fi := range fis {
@@ -317,12 +314,12 @@
// Safety / sanity check, the path under consideration for deletion MUST be
// underneath of our filesystem's root.
if !isSubpath(d.fs.rootDir, fiPath) {
- panic(errors.Reason("about to delete [%(path)q], which is not a subdirectory of [%(root)q]").
- D("path", fiPath).D("root", d.fs.rootDir).Err())
+ panic(errors.Reason("about to delete [%q], which is not a subdirectory of [%q]",
+ fiPath, d.fs.rootDir).Err())
}
if err := os.RemoveAll(fiPath); err != nil {
- return errors.Annotate(err).Reason("failed to delete unmanaged [%(path)q]").D("path", fiPath).Err()
+ return errors.Annotate(err, "failed to delete unmanaged [%q]", fiPath).Err()
}
}
return nil
@@ -355,15 +352,14 @@
// Assert that our "from" field exists.
if _, err := os.Stat(from); err != nil {
- return errors.Annotate(err).Reason("failed to stat symlink from [%(path)s]").
- D("path", from).Err()
+ return errors.Annotate(err, "failed to stat symlink from [%s]", from).Err()
}
// "from" must be a path under the filesystem base.
if rel {
var err error
if from, err = f.dir.RelPathFrom(from); err != nil {
- return errors.Annotate(err).Reason("failed to calculate relative path").Err()
+ return errors.Annotate(err, "failed to calculate relative path").Err()
}
}
@@ -384,8 +380,7 @@
}
if err := os.Symlink(from, to); err != nil {
- return errors.Annotate(err).Reason("failed to symlink [%(from)s] => [%(to)s]").
- D("from", from).D("to", to).Err()
+ return errors.Annotate(err, "failed to symlink [%s] => [%s]", from, to).Err()
}
return nil
}
@@ -396,8 +391,7 @@
s, err := os.Open(src)
if err != nil {
- return errors.Annotate(err).Reason("failed to open [%(source)s]").
- D("source", src).Err()
+ return errors.Annotate(err, "failed to open [%s]", src).Err()
}
defer func() {
cerr := s.Close()
@@ -408,8 +402,7 @@
d, err := createFile(dst)
if err != nil {
- return errors.Annotate(err).Reason("failed to create [%(dest)s]").
- D("dest", dst).Err()
+ return errors.Annotate(err, "failed to create [%s]", dst).Err()
}
defer func() {
cerr := d.Close()
@@ -422,8 +415,7 @@
_, err = io.CopyBuffer(d, s, buf)
})
if err != nil {
- return errors.Annotate(err).Reason("failed to copy from [%(source)s] => [%(dest)s]").
- D("source", src).D("dest", dst).Err()
+ return errors.Annotate(err, "failed to copy from [%s] => [%s]", src, dst).Err()
}
return nil
}
@@ -438,8 +430,7 @@
if isNotExist(err) {
return false, nil
}
- return false, errors.Annotate(err).Reason("failed to stat [%(self)s]").
- D("self", myPath).Err()
+ return false, errors.Annotate(err, "failed to stat [%s]", myPath).Err()
}
otherStat, err := os.Lstat(other)
@@ -447,8 +438,7 @@
if isNotExist(err) {
return false, nil
}
- return false, errors.Annotate(err).Reason("failed to stat [%(other)s]").
- D("other", other).Err()
+ return false, errors.Annotate(err, "failed to stat [%s]", other).Err()
}
if os.SameFile(myStat, otherStat) {
@@ -458,15 +448,13 @@
// Not the same file, and both exist, so let's compare byte-for-byte.
myFD, err := os.Open(f.String())
if err != nil {
- return false, errors.Annotate(err).Reason("failed to open [%(self)s]").
- D("self", myPath).Err()
+ return false, errors.Annotate(err, "failed to open [%s]", myPath).Err()
}
defer myFD.Close()
otherFD, err := os.Open(other)
if err != nil {
- return false, errors.Annotate(err).Reason("failed to option [%(other)s]").
- D("other", other).Err()
+ return false, errors.Annotate(err, "failed to option [%s]", other).Err()
}
defer otherFD.Close()
@@ -477,8 +465,7 @@
})
})
if err != nil {
- return false, errors.Annotate(err).Reason("failed to compare files [%(self)s] to [$(other)s]").
- D("self", myPath).D("other", other).Err()
+ return false, errors.Annotate(err, "failed to compare files [%s] to [%s]", myPath, other).Err()
}
return same, nil
}
@@ -511,7 +498,7 @@
// Write YAML contents.
if err := proto.MarshalText(fd, msg); err != nil {
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
}
return nil
})
@@ -549,7 +536,7 @@
// Write YAML contents.
if _, err := fd.Write(d); err != nil {
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
}
return nil
})
@@ -582,7 +569,7 @@
// Write Go content.
if _, err := fmt.Fprint(fd, content); err != nil {
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
}
return nil
})
diff --git a/deploytool/managedfs/util.go b/deploytool/managedfs/util.go
index b93fab8..08424ac 100644
--- a/deploytool/managedfs/util.go
+++ b/deploytool/managedfs/util.go
@@ -16,7 +16,7 @@
func ensureDirectory(path string) error {
if err := os.MkdirAll(path, 0755); err != nil {
- return errors.Annotate(err).Reason("failed to create directory [%(path)s]").D("path", path).Err()
+ return errors.Annotate(err, "failed to create directory [%s]", path).Err()
}
return nil
}
@@ -32,15 +32,15 @@
break
case err != nil:
- return nil, errors.Annotate(err).Reason("failed to lstat [%(path)s]").D("path", path).Err()
+ return nil, errors.Annotate(err, "failed to lstat [%s]", path).Err()
case st.IsDir():
- return nil, errors.Reason("cannot create; path [%(path)s] is a directory").D("path", path).Err()
+ return nil, errors.Reason("cannot create; path [%s] is a directory", path).Err()
default:
// Exists, and is a file/link, so unlink.
if err := os.Remove(path); err != nil {
- return nil, errors.Annotate(err).Reason("failed to remove existing [%(path)s]").D("path", path).Err()
+ return nil, errors.Annotate(err, "failed to remove existing [%s]", path).Err()
}
}
@@ -76,7 +76,7 @@
ac, err := a.Read(aBuf)
if err != nil {
if err != io.EOF {
- return false, errors.Annotate(err).Reason("failed to read").Err()
+ return false, errors.Annotate(err, "failed to read").Err()
}
ac = 0
done = true
@@ -85,7 +85,7 @@
bc, err := b.Read(bBuf)
if err != nil {
if err != io.EOF {
- return false, errors.Annotate(err).Reason("failed to read").Err()
+ return false, errors.Annotate(err, "failed to read").Err()
}
bc = 0
}
diff --git a/dm/appengine/deps/auth.go b/dm/appengine/deps/auth.go
index 4aca54a..a721b16 100644
--- a/dm/appengine/deps/auth.go
+++ b/dm/appengine/deps/auth.go
@@ -24,8 +24,8 @@
ret = &acls.Acls{}
if err := cfgclient.Get(c, cfgclient.AsService, cSet, file, textproto.Message(ret), nil); err != nil {
- return nil, errors.Annotate(err).Tag(transient.Tag).
- D("cSet", cSet).D("file", file).InternalReason("loading config").Err()
+ return nil, errors.Annotate(err, "").Tag(transient.Tag).
+ InternalReason("loading config :: cSet(%v)/file(%v)", cSet, file).Err()
}
return
}
@@ -34,7 +34,7 @@
for _, grp := range groups {
ok, err := auth.IsMember(c, grp)
if err != nil {
- return grpcAnnotate(err, codes.Internal).Reason("failed group check").Err()
+ return grpcAnnotate(err, codes.Internal, "failed group check").Err()
}
if ok {
return nil
diff --git a/dm/appengine/deps/ensure_graph_data.go b/dm/appengine/deps/ensure_graph_data.go
index bc567b6..38f4976 100644
--- a/dm/appengine/deps/ensure_graph_data.go
+++ b/dm/appengine/deps/ensure_graph_data.go
@@ -143,8 +143,7 @@
DoNotMergeQuest: true,
})
}
- return grpcAnnotate(tumble.AddToJournal(c, muts...), codes.Internal).
- Reason("attempting to journal").Err()
+ return grpcAnnotate(tumble.AddToJournal(c, muts...), codes.Internal, "attempting to journal").Err()
}
func (d *deps) ensureGraphData(c context.Context, req *dm.EnsureGraphDataReq, newQuests []*model.Quest, newAttempts *dm.AttemptList, rsp *dm.EnsureGraphDataRsp) (err error) {
@@ -176,7 +175,7 @@
}
})
if err != nil {
- return grpcAnnotate(err, codes.Internal).Reason("failed to gather prerequisites").Err()
+ return grpcAnnotate(err, codes.Internal, "failed to gather prerequisites").Err()
}
// Now that we've walked the graph, prune the lists of new Quest and Attempts
@@ -185,7 +184,7 @@
newQuests, newQuestSet := filterQuestsByNewTemplateData(rsp.Result, newQuests)
newAttempts, newAttemptsLen, err := filterAttemptsByDNE(rsp.Result, newAttempts, newQuestSet)
if err != nil {
- return grpcAnnotate(err, codes.InvalidArgument).Reason("filterAttemptsByDNE").Err()
+ return grpcAnnotate(err, codes.InvalidArgument, "filterAttemptsByDNE").Err()
}
// we're just asserting nodes, no edges, so journal whatever's left
@@ -299,8 +298,8 @@
}
if err = d.Validate(qDesc.DistributorParameters); err != nil {
- err = grpcAnnotate(err, codes.InvalidArgument).
- Reason("JSON distributor parameters are invalid for this distributor configuration.").Err()
+ err = grpcAnnotate(err, codes.InvalidArgument,
+ "JSON distributor parameters are invalid for this distributor configuration.").Err()
return
}
@@ -368,7 +367,7 @@
logging.Fields{"execution": req.ForExecution.Id}.Infof(c, "on behalf of")
_, _, err := model.AuthenticateExecution(c, req.ForExecution)
if err != nil {
- return nil, grpcAnnotate(err, codes.Unauthenticated).Reason("bad execution auth").Err()
+ return nil, grpcAnnotate(err, codes.Unauthenticated, "bad execution auth").Err()
}
} else {
if err = canWrite(c); err != nil {
diff --git a/dm/appengine/deps/service.go b/dm/appengine/deps/service.go
index 2c67361..eb125bf 100644
--- a/dm/appengine/deps/service.go
+++ b/dm/appengine/deps/service.go
@@ -5,7 +5,6 @@
package deps
import (
- "bytes"
"os"
"github.com/golang/protobuf/proto"
@@ -35,7 +34,7 @@
Normalize() error
}); ok {
if err := norm.Normalize(); err != nil {
- return nil, grpcAnnotate(err, codes.InvalidArgument).Reason("invalid request").Err()
+ return nil, grpcAnnotate(err, codes.InvalidArgument, "invalid request").Err()
}
}
return c, nil
@@ -65,9 +64,7 @@
printStack = !omitStack
}
if printStack {
- buf := &bytes.Buffer{}
- errors.RenderStack(err).DumpTo(buf)
- logging.Errorf(c, "%s", buf.String())
+ errors.Log(c, err)
} else {
logging.Infof(c, "returning gRPC code: %s", code)
}
diff --git a/dm/appengine/deps/util.go b/dm/appengine/deps/util.go
index 30d6fbd..03cb9ec 100644
--- a/dm/appengine/deps/util.go
+++ b/dm/appengine/deps/util.go
@@ -10,6 +10,6 @@
"google.golang.org/grpc/codes"
)
-func grpcAnnotate(err error, code codes.Code) *errors.Annotator {
- return errors.Annotate(err).Tag(grpcutil.Tag.With(code))
+func grpcAnnotate(err error, code codes.Code, reason string, args ...interface{}) *errors.Annotator {
+ return errors.Annotate(err, reason, args...).Tag(grpcutil.Tag.With(code))
}
diff --git a/dm/appengine/distributor/notify_execution.go b/dm/appengine/distributor/notify_execution.go
index bc46f2d..1538195 100644
--- a/dm/appengine/distributor/notify_execution.go
+++ b/dm/appengine/distributor/notify_execution.go
@@ -40,7 +40,7 @@
q := &model.Quest{ID: f.Notification.ID.Quest}
if err := ds.Get(ds.WithoutTransaction(c), q); err != nil {
- return nil, errors.Annotate(err).Reason("getting Quest").Err()
+ return nil, errors.Annotate(err, "getting Quest").Err()
}
rslt, err := dist.HandleNotification(&q.Desc, f.Notification)
if err != nil {
diff --git a/dm/appengine/distributor/swarming/v1/distributor.go b/dm/appengine/distributor/swarming/v1/distributor.go
index 4e8e6c6..7311c98 100644
--- a/dm/appengine/distributor/swarming/v1/distributor.go
+++ b/dm/appengine/distributor/swarming/v1/distributor.go
@@ -110,15 +110,13 @@
func parseParams(desc *dm.Quest_Desc) (ret *sv1.Parameters, err error) {
ret = &sv1.Parameters{}
if err = jsonpb.UnmarshalString(desc.DistributorParameters, ret); err != nil {
- err = errors.Annotate(err).
- Reason("unmarshalling DistributorParameters").
+ err = errors.Annotate(err, "unmarshalling DistributorParameters").
InternalReason("These paramaeters were already validated?").
Err()
return
}
if err = ret.Normalize(); err != nil {
- err = errors.Annotate(err).
- Reason("normalizing DistributorParameters").
+ err = errors.Annotate(err, "normalizing DistributorParameters").
InternalReason("These paramaeters were already normalized successfully once?").
Err()
return
@@ -138,7 +136,7 @@
if prev != nil {
prevParsed = &sv1.Result{}
if err = jsonpb.UnmarshalString(prev.Object, prevParsed); err != nil {
- err = errors.Annotate(err).Reason("parsing previous result").Err()
+ err = errors.Annotate(err, "parsing previous result").Err()
return
}
}
@@ -146,7 +144,7 @@
isoCtx, _ := context.WithTimeout(d, 30*time.Second)
iso, err := prepIsolate(isoCtx, d.sCfg.Isolate.Url, desc, prev, params)
if err != nil {
- err = errors.Annotate(err).Reason("prepping Isolated").Err()
+ err = errors.Annotate(err, "prepping Isolated").Err()
return
}
@@ -166,7 +164,7 @@
topic, token, err := d.cfg.PrepareTopic(d, auth.Id)
if err != nil {
- err = errors.Annotate(err).Reason("preparing topic").Err()
+ err = errors.Annotate(err, "preparing topic").Err()
return
}
@@ -222,7 +220,7 @@
return
}, retry.LogCallback(d, "swarm.Tasks.New"))
if err != nil {
- err = errors.Annotate(err).Reason("calling swarm.Tasks.New").Err()
+ err = errors.Annotate(err, "calling swarm.Tasks.New").Err()
return
}
@@ -362,9 +360,9 @@
func (*swarmingDist) Validate(payload string) error {
msg := &sv1.Parameters{}
if err := jsonpb.UnmarshalString(payload, msg); err != nil {
- return errors.Annotate(err).Reason("unmarshal").D("payload", payload).Err()
+ return errors.Annotate(err, "unmarshal").InternalReason("payload(%v)", payload).Err()
}
- return errors.Annotate(msg.Normalize()).Reason("normalize").D("payload", payload).Err()
+ return errors.Annotate(msg.Normalize(), "normalize").InternalReason("payload(%v)", payload).Err()
}
func factory(c context.Context, cfg *distributor.Config) (distributor.D, error) {
diff --git a/dm/appengine/distributor/swarming/v1/isolate.go b/dm/appengine/distributor/swarming/v1/isolate.go
index a829dc7..e503a25 100644
--- a/dm/appengine/distributor/swarming/v1/isolate.go
+++ b/dm/appengine/distributor/swarming/v1/isolate.go
@@ -94,10 +94,7 @@
anonC, authC, isolateURL, isolatedclient.DefaultNamespace, nil, nil)
states, err := isoClient.Contains(c, dgsts)
if err != nil {
- err = errors.Annotate(err).
- D("count", len(dgsts)).
- Reason("checking containment for %(count)d digests").
- Err()
+ err = errors.Annotate(err, "checking containment for %d digests", len(dgsts)).Err()
return err
}
return parallel.FanOutIn(func(ch chan<- func() error) {
@@ -127,7 +124,7 @@
{data: isoData, file: isoFile, isIso: true},
})
if err != nil {
- err = errors.Annotate(err).Reason("pushing new Isolated").Err()
+ err = errors.Annotate(err, "pushing new Isolated").Err()
return nil, err
}
diff --git a/dm/appengine/mutate/add_deps.go b/dm/appengine/mutate/add_deps.go
index 0645ffa..5f34cec 100644
--- a/dm/appengine/mutate/add_deps.go
+++ b/dm/appengine/mutate/add_deps.go
@@ -51,8 +51,7 @@
}
fwdDeps, err := filterExisting(c, model.FwdDepsFromList(c, a.Auth.Id.AttemptID(), a.Deps))
- err = errors.Annotate(err).Tag(grpcutil.Tag.With(codes.Internal)).
- Reason("while filtering deps").Err()
+ err = errors.Annotate(err, "while filtering deps").Tag(grpcutil.Tag.With(codes.Internal)).Err()
if err != nil || len(fwdDeps) == 0 {
return
}
@@ -66,8 +65,7 @@
}
if err = ds.Put(c, fwdDeps, atmpt, ex); err != nil {
- err = errors.Annotate(err).Tag(grpcutil.Tag.With(codes.Internal)).
- Reason("putting stuff").Err()
+ err = errors.Annotate(err, "putting stuff").Tag(grpcutil.Tag.With(codes.Internal)).Err()
return
}
diff --git a/dm/appengine/mutate/finish_attempt.go b/dm/appengine/mutate/finish_attempt.go
index ba1ee13..0ccfd8f 100644
--- a/dm/appengine/mutate/finish_attempt.go
+++ b/dm/appengine/mutate/finish_attempt.go
@@ -55,8 +55,7 @@
atmpt.Result.Data = &rslt
atmpt.Result.Data.Object = ""
- err = errors.Annotate(ds.Put(c, atmpt, ar)).Tag(grpcutil.Tag.With(codes.Internal)).
- Reason("during Put").Err()
+ err = errors.Annotate(ds.Put(c, atmpt, ar), "during Put").Tag(grpcutil.Tag.With(codes.Internal)).Err()
return
}
diff --git a/dm/appengine/mutate/timeout_execution.go b/dm/appengine/mutate/timeout_execution.go
index 15c9a12..6fbc640 100644
--- a/dm/appengine/mutate/timeout_execution.go
+++ b/dm/appengine/mutate/timeout_execution.go
@@ -87,7 +87,7 @@
var realRslt *dm.Result
q := model.QuestFromID(t.For.Quest)
if err = ds.Get(ds.WithoutTransaction(c), q); err != nil {
- err = errors.Annotate(err).Reason("loading quest").Err()
+ err = errors.Annotate(err, "loading quest").Err()
return
}
realRslt, err = dist.GetStatus(&q.Desc, distributor.Token(e.DistributorToken))
diff --git a/dm/tools/dmtool/vizQuery.go b/dm/tools/dmtool/vizQuery.go
index e12f431..6699430 100644
--- a/dm/tools/dmtool/vizQuery.go
+++ b/dm/tools/dmtool/vizQuery.go
@@ -234,7 +234,7 @@
for c.Err() == nil {
gdata, err := runQuery(c, dc, query)
if err != nil {
- if errors.Contains(err, context.Canceled) {
+ if errors.Any(err, func(err error) bool { return err == context.Canceled }) {
return 0
}
logging.WithError(err).Errorf(c, "error running query")
diff --git a/grpc/grpcutil/errors.go b/grpc/grpcutil/errors.go
index e34f321..e589ac3 100644
--- a/grpc/grpcutil/errors.go
+++ b/grpc/grpcutil/errors.go
@@ -89,7 +89,9 @@
type grpcCodeTag struct{ Key errors.TagKey }
-func (g grpcCodeTag) With(code codes.Code) errors.TagValue { return errors.MkTagValue(g.Key, code) }
+func (g grpcCodeTag) With(code codes.Code) errors.TagValue {
+ return errors.TagValue{Key: g.Key, Value: code}
+}
func (g grpcCodeTag) In(err error) (v codes.Code, ok bool) {
d, ok := errors.TagValueIn(g.Key, err)
if ok {
diff --git a/grpc/prpc/client.go b/grpc/prpc/client.go
index 971a8c0..d958196 100644
--- a/grpc/prpc/client.go
+++ b/grpc/prpc/client.go
@@ -204,8 +204,7 @@
}
if err != nil {
// Treat all errors here as transient.
- return errors.Annotate(err).Reason("failed to send request").
- Tag(transient.Tag).Err()
+ return errors.Annotate(err, "failed to send request").Tag(transient.Tag).Err()
}
if options.resHeaderMetadata != nil {
diff --git a/logdog/appengine/coordinator/endpoints/logs/get.go b/logdog/appengine/coordinator/endpoints/logs/get.go
index 64478d0..0076835 100644
--- a/logdog/appengine/coordinator/endpoints/logs/get.go
+++ b/logdog/appengine/coordinator/endpoints/logs/get.go
@@ -140,7 +140,7 @@
svc := coordinator.GetServices(c)
st, err := svc.StorageForStream(c, lst)
if err != nil {
- return errors.Annotate(err).InternalReason("failed to create storage instance").Err()
+ return errors.Annotate(err, "").InternalReason("failed to create storage instance").Err()
}
defer st.Close()
@@ -166,7 +166,7 @@
signedURLs, err := st.GetSignedURLs(c, &signingRequest)
switch {
case err != nil:
- return errors.Annotate(err).InternalReason("failed to generate signed URL").Err()
+ return errors.Annotate(err, "").InternalReason("failed to generate signed URL").Err()
case signedURLs == nil:
log.Debugf(c, "Signed URL was requested, but is not supported by storage.")
diff --git a/logdog/appengine/coordinator/service.go b/logdog/appengine/coordinator/service.go
index a12b96d..c5e51e3 100644
--- a/logdog/appengine/coordinator/service.go
+++ b/logdog/appengine/coordinator/service.go
@@ -508,13 +508,13 @@
func (si *googleStorage) GetSignedURLs(c context.Context, req *URLSigningRequest) (*URLSigningResponse, error) {
info, err := si.svc.signer.ServiceInfo(c)
if err != nil {
- return nil, errors.Annotate(err).InternalReason("failed to get service info").Err()
+ return nil, errors.Annotate(err, "").InternalReason("failed to get service info").Err()
}
lifetime := req.Lifetime
switch {
case lifetime < 0:
- return nil, errors.Reason("invalid signed URL lifetime: %(lifetime)s").D("lifetime", lifetime).Err()
+ return nil, errors.Reason("invalid signed URL lifetime: %s", lifetime).Err()
case lifetime > maxSignedURLLifetime:
lifetime = maxSignedURLLifetime
@@ -537,8 +537,8 @@
doSign := func(path gs.Path) (string, error) {
url, err := gcst.SignedURL(path.Bucket(), path.Filename(), &opts)
if err != nil {
- return "", errors.Annotate(err).InternalReason("failed to sign URL").
- D("bucket", path.Bucket()).D("filename", path.Filename).Err()
+ return "", errors.Annotate(err, "").InternalReason(
+ "failed to sign URL: bucket(%s)/filename(%s)", path.Bucket(), path.Filename).Err()
}
return url, nil
}
@@ -546,14 +546,14 @@
// Sign stream URL.
if req.Stream {
if resp.Stream, err = doSign(si.stream); err != nil {
- return nil, errors.Annotate(err).InternalReason("failed to sign stream URL").Err()
+ return nil, errors.Annotate(err, "").InternalReason("failed to sign stream URL").Err()
}
}
// Sign index URL.
if req.Index {
if resp.Index, err = doSign(si.index); err != nil {
- return nil, errors.Annotate(err).InternalReason("failed to sign index URL").Err()
+ return nil, errors.Annotate(err, "").InternalReason("failed to sign index URL").Err()
}
}
diff --git a/logdog/client/butler/output/logdog/output.go b/logdog/client/butler/output/logdog/output.go
index afc9efd..6feee22 100644
--- a/logdog/client/butler/output/logdog/output.go
+++ b/logdog/client/butler/output/logdog/output.go
@@ -88,12 +88,12 @@
return nil, errors.New("no host supplied")
}
if err := cfg.Project.Validate(); err != nil {
- return nil, errors.Annotate(err).Reason("failed to validate project").
- D("project", cfg.Project).Err()
+ return nil, errors.Annotate(err, "failed to validate project").
+ InternalReason("project(%v)", cfg.Project).Err()
}
if err := cfg.Prefix.Validate(); err != nil {
- return nil, errors.Annotate(err).Reason("failed to validate prefix").
- D("prefix", cfg.Prefix).Err()
+ return nil, errors.Annotate(err, "failed to validate prefix").
+ InternalReason("prefix(%v)", cfg.Prefix).Err()
}
// Open a pRPC client to our Coordinator instance.
diff --git a/logdog/client/butler/streamserver/namedPipe_posix.go b/logdog/client/butler/streamserver/namedPipe_posix.go
index eb37804..df118dc 100644
--- a/logdog/client/butler/streamserver/namedPipe_posix.go
+++ b/logdog/client/butler/streamserver/namedPipe_posix.go
@@ -32,17 +32,13 @@
case l == 0:
return nil, errors.New("cannot have empty path")
case l > maxPOSIXNamedSocketLength:
- return nil, errors.Reason("path exceeds maximum length %(max)d").
- D("path", path).
- D("max", maxPOSIXNamedSocketLength).
- Err()
+ return nil, errors.Reason("path exceeds maximum length %d", maxPOSIXNamedSocketLength).
+ InternalReason("path(%s)", path).Err()
}
abs, err := filepath.Abs(path)
if err != nil {
- return nil, errors.Annotate(err).Reason("could not get absolute path of [%(path)s]").
- D("path", path).
- Err()
+ return nil, errors.Annotate(err, "could not get absolute path of [%s]", path).Err()
}
path = abs
diff --git a/logdog/client/butler/streamserver/namedPipe_windows.go b/logdog/client/butler/streamserver/namedPipe_windows.go
index fb3d0c0..1a90cf9 100644
--- a/logdog/client/butler/streamserver/namedPipe_windows.go
+++ b/logdog/client/butler/streamserver/namedPipe_windows.go
@@ -25,10 +25,8 @@
case l == 0:
return nil, errors.New("cannot have empty name")
case l > maxWindowsNamedPipeLength:
- return nil, errors.Reason("name exceeds maximum length %(max)d").
- D("name", name).
- D("max", maxWindowsNamedPipeLength).
- Err()
+ return nil, errors.Reason("name exceeds maximum length %d", maxWindowsNamedPipeLength).
+ InternalReason("name(%s)", name).Err()
}
ctx = log.SetField(ctx, "name", name)
@@ -44,7 +42,7 @@
l, err := winio.ListenPipe(pipePath, nil)
if err != nil {
- return nil, "", errors.Annotate(err).Reason("failed to listen on named pipe").Err()
+ return nil, "", errors.Annotate(err, "failed to listen on named pipe").Err()
}
return l, address, nil
},
diff --git a/logdog/client/butler/streamserver/tcp.go b/logdog/client/butler/streamserver/tcp.go
index 057d7e4..f90d5b0 100644
--- a/logdog/client/butler/streamserver/tcp.go
+++ b/logdog/client/butler/streamserver/tcp.go
@@ -57,10 +57,7 @@
func newTCPServerImpl(ctx context.Context, netType, spec string, loopback net.IP) (StreamServer, error) {
tcpAddr, err := net.ResolveTCPAddr(netType, spec)
if err != nil {
- return nil, errors.Annotate(err).Reason("could not resolve %(net)q address %(addr)q").
- D("net", netType).
- D("addr", spec).
- Err()
+ return nil, errors.Annotate(err, "could not resolve %q address %q", netType, spec).Err()
}
if tcpAddr.IP == nil {
@@ -73,10 +70,7 @@
gen: func() (net.Listener, string, error) {
l, err := net.ListenTCP(netType, tcpAddr)
if err != nil {
- return nil, "", errors.Annotate(err).Reason("failed to listen to %(net)q address %(addr)q").
- D("net", netType).
- D("addr", tcpAddr).
- Err()
+ return nil, "", errors.Annotate(err, "failed to listen to %q address %q", netType, tcpAddr).Err()
}
addr := fmt.Sprintf("%s:%s", netType, l.Addr().String())
diff --git a/logdog/client/butlerlib/bootstrap/bootstrap.go b/logdog/client/butlerlib/bootstrap/bootstrap.go
index ce39b7f..789a1f1 100644
--- a/logdog/client/butlerlib/bootstrap/bootstrap.go
+++ b/logdog/client/butlerlib/bootstrap/bootstrap.go
@@ -74,7 +74,7 @@
func (bs *Bootstrap) initializeClient(v string, reg *streamclient.Registry) error {
c, err := reg.NewClient(v)
if err != nil {
- return errors.Annotate(err).Reason("bootstrap: failed to create stream client [%(config)s]").D("config", v).Err()
+ return errors.Annotate(err, "bootstrap: failed to create stream client [%s]", v).Err()
}
bs.Client = c
return nil
diff --git a/logdog/client/butlerlib/streamclient/tcp.go b/logdog/client/butlerlib/streamclient/tcp.go
index 058be48..16ee407 100644
--- a/logdog/client/butlerlib/streamclient/tcp.go
+++ b/logdog/client/butlerlib/streamclient/tcp.go
@@ -15,16 +15,11 @@
return func(spec string) (Client, error) {
raddr, err := net.ResolveTCPAddr(netType, spec)
if err != nil {
- return nil, errors.Annotate(err).Reason("could not resolve %(net)q address from %(spec)q").
- D("net", netType).
- D("spec", spec).
- Err()
+ return nil, errors.Annotate(err, "could not resolve %q address from %q", netType, spec).Err()
}
if raddr.IP == nil || raddr.IP.IsUnspecified() {
- return nil, errors.Reason("a valid %(net)q address must be provided").
- D("net", netType).
- Err()
+ return nil, errors.Reason("a valid %q address must be provided", netType).Err()
}
if raddr.Port <= 0 {
@@ -35,10 +30,7 @@
factory: func() (io.WriteCloser, error) {
conn, err := net.DialTCP(netType, nil, raddr)
if err != nil {
- return nil, errors.Annotate(err).Reason("failed to dial %(net)q address %(raddr)q").
- D("net", netType).
- D("raddr", raddr).
- Err()
+ return nil, errors.Annotate(err, "failed to dial %q address %q", netType, raddr).Err()
}
return conn, nil
},
diff --git a/logdog/client/cli/main.go b/logdog/client/cli/main.go
index caba45c..fbf4343 100644
--- a/logdog/client/cli/main.go
+++ b/logdog/client/cli/main.go
@@ -123,7 +123,7 @@
func (a *application) coordinatorClient(host string) (*coordinator.Client, error) {
host, err := a.resolveHost(host)
if err != nil {
- return nil, errors.Annotate(err).Err()
+ return nil, errors.Annotate(err, "").Err()
}
// Get our Coordinator client instance.
diff --git a/logdog/client/cli/subcommandCat.go b/logdog/client/cli/subcommandCat.go
index a770eae..4f4aad2 100644
--- a/logdog/client/cli/subcommandCat.go
+++ b/logdog/client/cli/subcommandCat.go
@@ -121,8 +121,7 @@
}
if addr.Host, err = a.resolveHost(""); err != nil {
- err = errors.Annotate(err).Reason("failed to resolve host: %(host)q").
- D("host", addr.Host).Err()
+ err = errors.Annotate(err, "failed to resolve host: %q", addr.Host).Err()
errors.Log(a, err)
return 1
}
@@ -143,8 +142,7 @@
var err error
if coords[addr.Host], err = a.coordinatorClient(addr.Host); err != nil {
- err = errors.Annotate(err).Reason("failed to create Coordinator client for %(host)q").
- D("host", addr.Host).Err()
+ err = errors.Annotate(err, "failed to create Coordinator client for %q", addr.Host).Err()
errors.Log(a, err)
return 1
diff --git a/logdog/client/cli/subcommandLatest.go b/logdog/client/cli/subcommandLatest.go
index 1df9198..e56c829 100644
--- a/logdog/client/cli/subcommandLatest.go
+++ b/logdog/client/cli/subcommandLatest.go
@@ -74,7 +74,7 @@
coord, err := a.coordinatorClient(addr.Host)
if err != nil {
- errors.Log(a, errors.Annotate(err).Reason("failed to create Coordinator client").Err())
+ errors.Log(a, errors.Annotate(err, "failed to create Coordinator client").Err())
return 1
}
diff --git a/logdog/client/cli/subcommandList.go b/logdog/client/cli/subcommandList.go
index b43c7ff..4c79f32 100644
--- a/logdog/client/cli/subcommandList.go
+++ b/logdog/client/cli/subcommandList.go
@@ -60,7 +60,7 @@
coord, err := a.coordinatorClient("")
if err != nil {
- errors.Log(a, errors.Annotate(err).Reason("could not create Coordinator client").Err())
+ errors.Log(a, errors.Annotate(err, "could not create Coordinator client").Err())
return 1
}
diff --git a/logdog/client/cli/subcommandQuery.go b/logdog/client/cli/subcommandQuery.go
index 6e303cc..159eb40 100644
--- a/logdog/client/cli/subcommandQuery.go
+++ b/logdog/client/cli/subcommandQuery.go
@@ -77,7 +77,7 @@
coord, err := a.coordinatorClient("")
if err != nil {
- errors.Log(a, errors.Annotate(err).Reason("could not create Coordinator client").Err())
+ errors.Log(a, errors.Annotate(err, "could not create Coordinator client").Err())
return 1
}
diff --git a/logdog/client/cmd/logdog_butler/main.go b/logdog/client/cmd/logdog_butler/main.go
index e457148..3a53aeb 100644
--- a/logdog/client/cmd/logdog_butler/main.go
+++ b/logdog/client/cmd/logdog_butler/main.go
@@ -5,7 +5,6 @@
package main
import (
- "bytes"
"flag"
"fmt"
"net/http"
@@ -217,15 +216,8 @@
return
}
- var buf bytes.Buffer
- st := errors.RenderStack(err)
- if _, derr := st.DumpTo(&buf); derr != nil {
- // This can't really fail, since we're rendering to a Buffer.
- panic(derr)
- }
-
nargs := make([]interface{}, len(args)+1)
- nargs[copy(nargs, args)] = buf.Bytes()
+ nargs[copy(nargs, args)] = strings.Join(errors.RenderStack(err), "\n")
if f == "" {
f = "Captured error stack:"
diff --git a/logdog/client/cmd/logdog_butler/output_logdog.go b/logdog/client/cmd/logdog_butler/output_logdog.go
index 2e567fb..9883859 100644
--- a/logdog/client/cmd/logdog_butler/output_logdog.go
+++ b/logdog/client/cmd/logdog_butler/output_logdog.go
@@ -49,7 +49,7 @@
func (f *logdogOutputFactory) configOutput(a *application) (output.Output, error) {
auth, err := a.authenticator(a)
if err != nil {
- return nil, errors.Annotate(err).Reason("failed to instantiate authenticator").Err()
+ return nil, errors.Annotate(err, "failed to instantiate authenticator").Err()
}
host := a.coordinatorHost
diff --git a/logdog/client/cmd/logdog_butler/streamserver.go b/logdog/client/cmd/logdog_butler/streamserver.go
index baff8c2..dbeac99 100644
--- a/logdog/client/cmd/logdog_butler/streamserver.go
+++ b/logdog/client/cmd/logdog_butler/streamserver.go
@@ -83,8 +83,6 @@
return streamserver.NewTCP6Server(ctx, spec)
default:
- return nil, errors.Reason("unknown stream server type: %(type)q").
- D("type", typ).
- Err()
+ return nil, errors.Reason("unknown stream server type: %q", typ).Err()
}
}
diff --git a/logdog/client/cmd/logdog_butler/subcommand_run.go b/logdog/client/cmd/logdog_butler/subcommand_run.go
index be5afa1..6ec39ae 100644
--- a/logdog/client/cmd/logdog_butler/subcommand_run.go
+++ b/logdog/client/cmd/logdog_butler/subcommand_run.go
@@ -305,19 +305,19 @@
// Add our pipes as direct streams, if configured.
if stdout != nil {
if err := b.AddStream(stdout, cmd.stdout.properties()); err != nil {
- return errors.Annotate(err).Reason("failed to attach STDOUT pipe stream").Err()
+ return errors.Annotate(err, "failed to attach STDOUT pipe stream").Err()
}
}
if stderr != nil {
if err := b.AddStream(stderr, cmd.stderr.properties()); err != nil {
- return errors.Annotate(err).Reason("failed to attach STDERR pipe stream").Err()
+ return errors.Annotate(err, "failed to attach STDERR pipe stream").Err()
}
}
// Execute the command. The bootstrapped application will begin executing
// in the background.
if err := proc.Start(); err != nil {
- return errors.Annotate(err).Reason("failed to start bootstrapped process").Err()
+ return errors.Annotate(err, "failed to start bootstrapped process").Err()
}
// Wait for the process' streams to finish. We must do this before Wait()
@@ -345,7 +345,7 @@
if err == context.Canceled {
return err
}
- return errors.Annotate(err).Reason("failed to Wait() for Butler").Err()
+ return errors.Annotate(err, "failed to Wait() for Butler").Err()
}
return nil
@@ -379,8 +379,8 @@
"path": cmd.resultPath,
}.Debugf(ctx, "Writing bootstrap result.")
if err := r.WriteJSON(cmd.resultPath); err != nil {
- return errors.Annotate(err).Reason("failed to write JSON file").
- D("path", cmd.resultPath).Err()
+ return errors.Annotate(err, "failed to write JSON file").
+ InternalReason("path(%s)", cmd.resultPath).Err()
}
return nil
}
diff --git a/logdog/client/cmd/logdog_butler/subcommand_stream.go b/logdog/client/cmd/logdog_butler/subcommand_stream.go
index 6fe2b26..e02b64a 100644
--- a/logdog/client/cmd/logdog_butler/subcommand_stream.go
+++ b/logdog/client/cmd/logdog_butler/subcommand_stream.go
@@ -92,7 +92,7 @@
// Instantiate our Processor.
err = a.runWithButler(output, func(b *butler.Butler) error {
if err := b.AddStream(streamFile, cmd.stream.properties()); err != nil {
- return errors.Annotate(err).Reason("failed to add stream").Err()
+ return errors.Annotate(err, "failed to add stream").Err()
}
b.Activate()
diff --git a/logdog/common/storage/archive/logdog_archive_test/main.go b/logdog/common/storage/archive/logdog_archive_test/main.go
index 2b5132b..77b4d0a 100644
--- a/logdog/common/storage/archive/logdog_archive_test/main.go
+++ b/logdog/common/storage/archive/logdog_archive_test/main.go
@@ -13,6 +13,7 @@
"io/ioutil"
"math"
"os"
+ "strings"
"github.com/luci/luci-go/client/authcli"
"github.com/luci/luci-go/common/auth"
@@ -54,7 +55,7 @@
authenticator := auth.NewAuthenticator(c, auth.OptionalLogin, a.authOpts)
transport, err := authenticator.Transport()
if err != nil {
- return nil, errors.Annotate(err).Reason("failed to get auth transport").Err()
+ return nil, errors.Annotate(err, "failed to get auth transport").Err()
}
return gs.NewProdClient(c, transport)
}
@@ -117,11 +118,8 @@
}
func renderErr(c context.Context, err error) {
- rerr := errors.RenderStack(err)
-
- var buf bytes.Buffer
- rerr.DumpTo(&buf)
- log.Errorf(c, "Error encountered during operation: %s\n%s", err, buf.Bytes())
+ log.Errorf(c, "Error encountered during operation: %s\n%s", err,
+ strings.Join(errors.RenderStack(err), "\n"))
}
////////////////////////////////////////////////////////////////////////////////
@@ -251,14 +249,14 @@
var desc logpb.LogStreamDescriptor
if err := unmarshalAndDump(c, os.Stdout, d, &desc); err != nil {
- return errors.Annotate(err).Reason("failed to dump log descriptor").Err()
+ return errors.Annotate(err, "failed to dump log descriptor").Err()
}
return nil
}
var entry logpb.LogEntry
if err := unmarshalAndDump(c, os.Stdout, d, &entry); err != nil {
- return errors.Annotate(err).Reason("failed to dump log entry").Err()
+ return errors.Annotate(err, "failed to dump log entry").Err()
}
return nil
})
@@ -464,8 +462,8 @@
break
default:
- return errors.Annotate(err).Reason("Encountered error reading log stream.").
- D("frameIndex", frameIndex).Err()
+ return errors.Annotate(err, "Encountered error reading log stream.").
+ InternalReason("frameIndex(%d)", frameIndex).Err()
}
if frameSize > 0 {
@@ -473,8 +471,8 @@
buf.Grow(int(frameSize))
if _, err := buf.ReadFrom(r); err != nil {
- return errors.Annotate(err).Reason("Failed to buffer frame.").
- D("frameIndex", frameIndex).Err()
+ return errors.Annotate(err, "Failed to buffer frame.").
+ InternalReason("frameIndex(%d)", frameIndex).Err()
}
if err := cb(c, buf.Bytes()); err != nil {
diff --git a/logdog/common/storage/archive/storage.go b/logdog/common/storage/archive/storage.go
index deeea38..f2f55b7 100644
--- a/logdog/common/storage/archive/storage.go
+++ b/logdog/common/storage/archive/storage.go
@@ -116,7 +116,7 @@
return storage.ErrDoesNotExist
default:
- return errors.Annotate(err).Reason("failed to read log stream").Err()
+ return errors.Annotate(err, "failed to read log stream").Err()
}
}
@@ -138,7 +138,7 @@
storageReader, err := s.Client.NewReader(s.Stream, int64(offset), length)
if err != nil {
log.WithError(err).Errorf(s, "Failed to create stream Reader.")
- return errors.Annotate(err).Reason("failed to create stream Reader").Err()
+ return errors.Annotate(err, "failed to create stream Reader").Err()
}
defer func() {
if tmpErr := storageReader.Close(); tmpErr != nil {
@@ -163,7 +163,7 @@
sz, r, err := rio.ReadFrame()
if err != nil {
- return errors.Annotate(err).Reason("failed to read frame").Err()
+ return errors.Annotate(err, "failed to read frame").Err()
}
buf.Reset()
@@ -176,11 +176,11 @@
"frameOffset": offset,
"frameSize": sz,
}.Errorf(s, "Failed to read frame data.")
- return errors.Annotate(err).Reason("failed to read frame data").Err()
+ return errors.Annotate(err, "failed to read frame data").Err()
case amt != sz:
// If we didn't buffer the complete frame, we hit a premature EOF.
- return errors.Annotate(io.EOF).Reason("incomplete frame read").Err()
+ return errors.Annotate(io.EOF, "incomplete frame read").Err()
}
// If we read from offset 0, the first frame will be the log stream's
@@ -200,7 +200,7 @@
"frameOffset": offset,
"frameSize": sz,
}.Errorf(s, "Failed to get log entry index.")
- return errors.Annotate(err).Reason("failed to get log entry index").Err()
+ return errors.Annotate(err, "failed to get log entry index").Err()
case idx < st.startIndex:
// Skip this entry, as it's before the first requested entry.
@@ -328,7 +328,7 @@
r, err := client.NewReader(path, 0, -1)
if err != nil {
log.WithError(err).Errorf(c, "Failed to create index Reader.")
- return nil, errors.Annotate(err).Reason("failed to create index Reader").Err()
+ return nil, errors.Annotate(err, "failed to create index Reader").Err()
}
defer func() {
if err := r.Close(); err != nil {
@@ -338,14 +338,14 @@
if indexData, err = ioutil.ReadAll(r); err != nil {
log.WithError(err).Errorf(c, "Failed to read index.")
- return nil, errors.Annotate(err).Reason("failed to read index").Err()
+ return nil, errors.Annotate(err, "failed to read index").Err()
}
}
index := logpb.LogIndex{}
if err := proto.Unmarshal(indexData, &index); err != nil {
log.WithError(err).Errorf(c, "Failed to unmarshal index.")
- return nil, errors.Annotate(err).Reason("failed to unmarshal index").Err()
+ return nil, errors.Annotate(err, "failed to unmarshal index").Err()
}
// If the index is valid, but wasn't cached previously, then cache it.
diff --git a/logdog/common/storage/bigtable/logdog_bigtable_test/main.go b/logdog/common/storage/bigtable/logdog_bigtable_test/main.go
index d337608..ab6e482 100644
--- a/logdog/common/storage/bigtable/logdog_bigtable_test/main.go
+++ b/logdog/common/storage/bigtable/logdog_bigtable_test/main.go
@@ -7,10 +7,10 @@
package main
import (
- "bytes"
"flag"
"io"
"os"
+ "strings"
"github.com/luci/luci-go/client/authcli"
"github.com/luci/luci-go/common/auth"
@@ -62,7 +62,7 @@
a := auth.NewAuthenticator(c, auth.SilentLogin, app.authOpts)
tsrc, err := a.TokenSource()
if err != nil {
- return nil, errors.Annotate(err).Reason("failed to get token source").Err()
+ return nil, errors.Annotate(err, "failed to get token source").Err()
}
return bigtable.New(c, bigtable.Options{
@@ -147,11 +147,8 @@
}
func renderErr(c context.Context, err error) {
- rerr := errors.RenderStack(err)
-
- var buf bytes.Buffer
- rerr.DumpTo(&buf)
- log.Errorf(c, "Error encountered during operation: %s\n%s", err, buf.Bytes())
+ log.Errorf(c, "Error encountered during operation: %s\n%s", err,
+ strings.Join(errors.RenderStack(err), "\n"))
}
func unmarshalAndDump(c context.Context, out io.Writer, data []byte, msg proto.Message) error {
@@ -214,7 +211,7 @@
stClient, err := app.getBigTableClient(c)
if err != nil {
- renderErr(c, errors.Annotate(err).Reason("failed to create storage client").Err())
+ renderErr(c, errors.Annotate(err, "failed to create storage client").Err())
return 1
}
defer stClient.Close()
@@ -246,11 +243,11 @@
})
switch {
case innerErr != nil:
- renderErr(c, errors.Annotate(err).Reason("failed to process fetched log entries").Err())
+ renderErr(c, errors.Annotate(err, "failed to process fetched log entries").Err())
return 1
case err != nil:
- renderErr(c, errors.Annotate(err).Reason("Failed to Get log entries.").Err())
+ renderErr(c, errors.Annotate(err, "Failed to Get log entries.").Err())
return 1
}
}
@@ -298,7 +295,7 @@
stClient, err := app.getBigTableClient(c)
if err != nil {
- renderErr(c, errors.Annotate(err).Reason("failed to create storage client").Err())
+ renderErr(c, errors.Annotate(err, "failed to create storage client").Err())
return 1
}
defer stClient.Close()
@@ -307,7 +304,7 @@
log.Infof(c, "Tail round %d.", round+1)
e, err := stClient.Tail(cfgtypes.ProjectName(cmd.project), types.StreamPath(cmd.path))
if err != nil {
- renderErr(c, errors.Annotate(err).Reason("failed to tail log entries").Err())
+ renderErr(c, errors.Annotate(err, "failed to tail log entries").Err())
return 1
}
@@ -318,7 +315,7 @@
le, err := e.GetLogEntry()
if err != nil {
- renderErr(c, errors.Annotate(err).Reason("failed to unmarshal log entry").Err())
+ renderErr(c, errors.Annotate(err, "failed to unmarshal log entry").Err())
return 1
}
@@ -327,7 +324,7 @@
"size": len(e.D),
}.Debugf(c, "Dumping tail entry.")
if err := unmarshalAndDump(c, os.Stdout, nil, le); err != nil {
- renderErr(c, errors.Annotate(err).Reason("failed to dump log entry").Err())
+ renderErr(c, errors.Annotate(err, "failed to dump log entry").Err())
return 1
}
}
diff --git a/logdog/common/storage/entry.go b/logdog/common/storage/entry.go
index 2ff78ff..5df9607 100644
--- a/logdog/common/storage/entry.go
+++ b/logdog/common/storage/entry.go
@@ -68,7 +68,7 @@
var le logpb.LogEntry
if err := proto.Unmarshal(e.D, &le); err != nil {
- return nil, errors.Annotate(err).Reason("failed to unmarshal").Err()
+ return nil, errors.Annotate(err, "failed to unmarshal").Err()
}
e.le = &le
}
diff --git a/logdog/common/types/streamaddr.go b/logdog/common/types/streamaddr.go
index 2dca9dc..afe4a5e 100644
--- a/logdog/common/types/streamaddr.go
+++ b/logdog/common/types/streamaddr.go
@@ -78,14 +78,12 @@
func ParseURL(v string) (*StreamAddr, error) {
u, err := url.Parse(v)
if err != nil {
- return nil, errors.Annotate(err).Reason("failed to parse URL").Err()
+ return nil, errors.Annotate(err, "failed to parse URL").Err()
}
// Validate Scheme.
if u.Scheme != logDogURLScheme {
- return nil, errors.Reason("URL scheme %(scheme)q is not "+logDogURLScheme).
- D("scheme", u.Scheme).
- Err()
+ return nil, errors.Reason("URL scheme %q is not %s", u.Scheme, logDogURLScheme).Err()
}
addr := StreamAddr{
Host: u.Host,
@@ -93,22 +91,16 @@
parts := strings.SplitN(u.Path, "/", 3)
if len(parts) != 3 || len(parts[0]) != 0 {
- return nil, errors.Reason("URL path does not include both project and path components: %(path)s").
- D("path", u.Path).
- Err()
+ return nil, errors.Reason("URL path does not include both project and path components: %s", u.Path).Err()
}
addr.Project, addr.Path = cfgtypes.ProjectName(parts[1]), StreamPath(parts[2])
if err := addr.Project.Validate(); err != nil {
- return nil, errors.Annotate(err).Reason("invalid project name: %(project)q").
- D("project", addr.Project).
- Err()
+ return nil, errors.Annotate(err, "invalid project name: %q", addr.Project).Err()
}
if err := addr.Path.Validate(); err != nil {
- return nil, errors.Annotate(err).Reason("invalid stream path: %(path)q").
- D("path", addr.Path).
- Err()
+ return nil, errors.Annotate(err, "invalid stream path: %q", addr.Path).Err()
}
return &addr, nil
diff --git a/logdog/server/archivist/archivist.go b/logdog/server/archivist/archivist.go
index b1b3d53..829903b 100644
--- a/logdog/server/archivist/archivist.go
+++ b/logdog/server/archivist/archivist.go
@@ -538,7 +538,7 @@
err := sa.Storage.Get(sreq, func(e *storage.Entry) bool {
idx, err := e.GetStreamIndex()
if err != nil {
- ierr = errors.Annotate(err).Reason("could not get stream index").Err()
+ ierr = errors.Annotate(err, "could not get stream index").Err()
return false
}
diff --git a/logdog/server/service/config/poller.go b/logdog/server/service/config/poller.go
index d7abb80..e83a83c 100644
--- a/logdog/server/service/config/poller.go
+++ b/logdog/server/service/config/poller.go
@@ -92,10 +92,7 @@
func (p *ChangePoller) Refresh(c context.Context) error {
var meta cfgclient.Meta
if err := cfgclient.Get(c, cfgclient.AsService, p.ConfigSet, p.Path, nil, &meta); err != nil {
- return errors.Annotate(err).Reason("failed to reload config %(configSet)s :: %(path)s").
- D("configSet", p.ConfigSet).
- D("path", p.Path).
- Err()
+ return errors.Annotate(err, "failed to reload config %s :: %s", p.ConfigSet, p.Path).Err()
}
p.ContentHash = meta.ContentHash
diff --git a/logdog/server/service/service.go b/logdog/server/service/service.go
index a3e8ae1..2e19c1c 100644
--- a/logdog/server/service/service.go
+++ b/logdog/server/service/service.go
@@ -183,7 +183,7 @@
c = s.loggingFlags.Set(c)
if err := s.profiler.Start(); err != nil {
- return errors.Annotate(err).Reason("failed to start profiler").Err()
+ return errors.Annotate(err, "failed to start profiler").Err()
}
defer s.profiler.Stop()
@@ -400,7 +400,7 @@
}
u, err := url.Parse(ccfg.ConfigServiceUrl)
if err != nil {
- return errors.Annotate(err).Reason("failed to parse config service URL").Err()
+ return errors.Annotate(err, "failed to parse config service URL").Err()
}
host = u.Host
}
@@ -436,7 +436,7 @@
var meta cfgclient.Meta
cset, path := s.ServiceConfigPath()
if err := cfgclient.Get(*c, cfgclient.AsService, cset, path, textproto.Message(&s.serviceConfig), &meta); err != nil {
- return errors.Annotate(err).Reason("failed to load service config").Err()
+ return errors.Annotate(err, "failed to load service config").Err()
}
// Create a poller for our service config.
@@ -482,8 +482,7 @@
var pcfg svcconfig.ProjectConfig
msg, err := s.configCache.Get(c, cset, path, &pcfg)
if err != nil {
- return nil, errors.Annotate(err).Reason("failed to load project config from %(cset)s.%(path)s").
- D("cset", cset).D("path", path).Err()
+ return nil, errors.Annotate(err, "failed to load project config from %s.%s", cset, path).Err()
}
return msg.(*svcconfig.ProjectConfig), nil
}
diff --git a/luci_config/appengine/backend/datastore/ds.go b/luci_config/appengine/backend/datastore/ds.go
index ccb7f64..386ed85 100644
--- a/luci_config/appengine/backend/datastore/ds.go
+++ b/luci_config/appengine/backend/datastore/ds.go
@@ -143,7 +143,7 @@
// operation that is being performed.
encKey, err := caching.Encode(&key)
if err != nil {
- return nil, errors.Annotate(err).Reason("failed to encode cache key").Err()
+ return nil, errors.Annotate(err, "failed to encode cache key").Err()
}
// Construct a cache handler.
@@ -154,13 +154,13 @@
// Decode our response.
if v.Schema != dsCacheSchema {
- return nil, errors.Reason("response schema (%(resp)q) doesn't match current (%(cur)q)").
- D("resp", v.Schema).D("cur", dsCacheSchema).Err()
+ return nil, errors.Reason("response schema (%q) doesn't match current (%q)",
+ v.Schema, dsCacheSchema).Err()
}
cacheValue, err := caching.DecodeValue(v.Data)
if err != nil {
- return nil, errors.Annotate(err).Reason("failed to decode cached value").Err()
+ return nil, errors.Annotate(err, "failed to decode cached value").Err()
}
// Prune any responses that are not permitted for the supplied Authority.
@@ -250,7 +250,7 @@
// Decode the key into our caching key.
var ck caching.Key
if err := caching.Decode(key, &ck); err != nil {
- return v, errors.Annotate(err).Reason("failed to decode cache key").Err()
+ return v, errors.Annotate(err, "failed to decode cache key").Err()
}
var cv *caching.Value
@@ -258,7 +258,7 @@
// We have a currently-cached value, so decode it into "cv".
var err error
if cv, err = caching.DecodeValue(v.Data); err != nil {
- return v, errors.Annotate(err).Reason("failed to decode cache value").Err()
+ return v, errors.Annotate(err, "failed to decode cache value").Err()
}
}
@@ -272,7 +272,7 @@
// Perform a cache load on this value.
cv, err := dch.loader(c, ck, cv)
if err != nil {
- return v, errors.Annotate(err).Reason("failed to load cache value").Err()
+ return v, errors.Annotate(err, "failed to load cache value").Err()
}
keyDesc := ck.String()
@@ -281,7 +281,7 @@
// Encode the resulting cache value.
if v.Data, err = cv.Encode(); err != nil {
- return v, errors.Annotate(err).Reason("failed to encode cache value").Err()
+ return v, errors.Annotate(err, "failed to encode cache value").Err()
}
v.Schema = dsCacheSchema
v.Description = keyDesc + ": " + valueDesc
diff --git a/luci_config/appengine/backend/memcache/cache.go b/luci_config/appengine/backend/memcache/cache.go
index af39871..5a8d479 100644
--- a/luci_config/appengine/backend/memcache/cache.go
+++ b/luci_config/appengine/backend/memcache/cache.go
@@ -43,8 +43,7 @@
// Value was cached, successfully retrieved.
v, err := caching.DecodeValue(mci.Value())
if err != nil {
- return nil, errors.Annotate(err).Reason("failed to decode cache value from %(key)q").
- D("key", k).Err()
+ return nil, errors.Annotate(err, "failed to decode cache value from %q", k).Err()
}
return v, nil
@@ -60,17 +59,16 @@
err = func() error {
d, err := v.Encode()
if err != nil {
- return errors.Annotate(err).Reason("failed to encode value").Err()
+ return errors.Annotate(err, "failed to encode value").Err()
}
if len(d) > maxMemCacheSize {
- return errors.Reason("entry exceeds memcache size (%(size)d > %(max)d)").
- D("size", len(d)).D("max", maxMemCacheSize).Err()
+ return errors.Reason("entry exceeds memcache size (%d > %d)", len(d), maxMemCacheSize).Err()
}
item := mc.NewItem(c, k).SetValue(d).SetExpiration(exp)
if err := mc.Set(c, item); err != nil {
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
}
return nil
}()
diff --git a/luci_config/server/cfgclient/access/access.go b/luci_config/server/cfgclient/access/access.go
index 8f26f00..4b5c597 100644
--- a/luci_config/server/cfgclient/access/access.go
+++ b/luci_config/server/cfgclient/access/access.go
@@ -52,8 +52,8 @@
var pcfg configPB.ProjectCfg
if err := cfgclient.Get(c, cfgclient.AsService, projectConfigSet, cfgclient.ProjectConfigPath,
textproto.Message(&pcfg), nil); err != nil {
- return errors.Annotate(err).Reason("failed to load %(path)q in %(configSet)q").
- D("path", cfgclient.ProjectConfigPath).D("configSet", projectConfigSet).Err()
+ return errors.Annotate(err, "failed to load %q in %q",
+ cfgclient.ProjectConfigPath, projectConfigSet).Err()
}
id := identity.AnonymousIdentity
@@ -80,7 +80,7 @@
if len(checkGroups) > 0 {
switch canAccess, err := auth.IsMember(c, checkGroups...); {
case err != nil:
- return errors.Annotate(err).Reason("failed to check group membership").Err()
+ return errors.Annotate(err, "failed to check group membership").Err()
case canAccess:
return nil
}
diff --git a/luci_config/server/cfgclient/backend/authority.go b/luci_config/server/cfgclient/backend/authority.go
index 819fd87..a1b74a8 100644
--- a/luci_config/server/cfgclient/backend/authority.go
+++ b/luci_config/server/cfgclient/backend/authority.go
@@ -52,7 +52,7 @@
case AsUser:
return asUserJSON, nil
default:
- return nil, errors.Reason("unknown authority: %(auth)v").D("auth", a).Err()
+ return nil, errors.Reason("unknown authority: %v", a).Err()
}
}
@@ -66,7 +66,7 @@
case bytes.Equal(d, asUserJSON):
*a = AsUser
default:
- return errors.Reason("unknown authority JSON value: %(auth)v").D("auth", d).Err()
+ return errors.Reason("unknown authority JSON value: %v", d).Err()
}
return nil
}
diff --git a/luci_config/server/cfgclient/backend/caching/codec.go b/luci_config/server/cfgclient/backend/caching/codec.go
index bca4488..8d1c5e8 100644
--- a/luci_config/server/cfgclient/backend/caching/codec.go
+++ b/luci_config/server/cfgclient/backend/caching/codec.go
@@ -24,10 +24,10 @@
if err := enc.Encode(v); err != nil {
zw.Close()
- return nil, errors.Annotate(err).Reason("failed to JSON-encode").Err()
+ return nil, errors.Annotate(err, "failed to JSON-encode").Err()
}
if err := zw.Close(); err != nil {
- return nil, errors.Annotate(err).Reason("failed to Close zlib Writer").Err()
+ return nil, errors.Annotate(err, "failed to Close zlib Writer").Err()
}
return buf.Bytes(), nil
}
@@ -37,12 +37,12 @@
func Decode(d []byte, v interface{}) error {
zr, err := zlib.NewReader(bytes.NewReader(d))
if err != nil {
- return errors.Annotate(err).Reason("failed to create zlib Reader").Err()
+ return errors.Annotate(err, "failed to create zlib Reader").Err()
}
defer zr.Close()
if err := json.NewDecoder(zr).Decode(v); err != nil {
- return errors.Annotate(err).Reason("failed to JSON-decode").Err()
+ return errors.Annotate(err, "failed to JSON-decode").Err()
}
return nil
}
diff --git a/luci_config/server/cfgclient/backend/caching/config.go b/luci_config/server/cfgclient/backend/caching/config.go
index d30df89..97e7e50 100644
--- a/luci_config/server/cfgclient/backend/caching/config.go
+++ b/luci_config/server/cfgclient/backend/caching/config.go
@@ -202,7 +202,7 @@
func DecodeValue(d []byte) (*Value, error) {
var v Value
if err := Decode(d, &v); err != nil {
- return nil, errors.Annotate(err).Err()
+ return nil, errors.Annotate(err, "").Err()
}
return &v, nil
}
@@ -290,7 +290,7 @@
"configSet": configSet,
"path": path,
}.Errorf(c, "(Hard Failure) failed to load cache value.")
- return nil, errors.Annotate(err).Err()
+ return nil, errors.Annotate(err, "").Err()
}
log.Fields{
@@ -332,7 +332,7 @@
"type": t,
"path": path,
}.Errorf(c, "(Hard Failure) failed to load cache value.")
- return nil, errors.Annotate(err).Err()
+ return nil, errors.Annotate(err, "").Err()
}
log.Fields{
@@ -364,7 +364,7 @@
"authority": p.Authority,
"configSet": configSet,
}.Errorf(c, "(Hard Failure) failed to load cache value.")
- err = errors.Annotate(err).Err()
+ err = errors.Annotate(err, "").Err()
return
}
@@ -384,7 +384,7 @@
up, err := url.Parse(value.URL)
if err != nil {
- err = errors.Annotate(err).Reason("failed to parse cached URL: %(value)q").D("value", value.URL).Err()
+ err = errors.Annotate(err, "failed to parse cached URL: %q", value.URL).Err()
return
}
@@ -415,7 +415,7 @@
case OpConfigSetURL:
rv, err = doConfigSetURL(c, b, k.ConfigSet, k.Params())
default:
- return nil, errors.Reason("unknown operation: %(op)v").D("op", k.Op).Err()
+ return nil, errors.Reason("unknown operation: %v", k.Op).Err()
}
if err != nil {
return nil, err
@@ -459,7 +459,7 @@
return v, nil
default:
- return nil, errors.Annotate(err).Err()
+ return nil, errors.Annotate(err, "").Err()
}
}
@@ -475,7 +475,7 @@
return v, nil
default:
- return nil, errors.Annotate(err).Err()
+ return nil, errors.Annotate(err, "").Err()
}
}
@@ -492,7 +492,7 @@
items, err := b.GetAll(c, t, path, noContentP)
if err != nil {
- return nil, errors.Annotate(err).Reason("failed RPC (hash-only)").Err()
+ return nil, errors.Annotate(err, "failed RPC (hash-only)").Err()
}
// If we already have a cached item, validate it.
@@ -526,7 +526,7 @@
// Perform a full-content request.
items, err := b.GetAll(c, t, path, p)
if err != nil {
- return nil, errors.Annotate(err).Err()
+ return nil, errors.Annotate(err, "").Err()
}
var retV Value
retV.LoadItems(items...)
diff --git a/luci_config/server/cfgclient/backend/client/client.go b/luci_config/server/cfgclient/backend/client/client.go
index 57969a7..c28cc35 100644
--- a/luci_config/server/cfgclient/backend/client/client.go
+++ b/luci_config/server/cfgclient/backend/client/client.go
@@ -75,7 +75,7 @@
case backend.GetAllRef:
fn = svc.GetRefConfigs
default:
- return nil, errors.Reason("unknown GetAllType: %(type)q").D("type", t).Err()
+ return nil, errors.Reason("unknown GetAllType: %q", t).Err()
}
cfgs, err := fn(c, path, !p.Content)
diff --git a/luci_config/server/cfgclient/backend/format/format.go b/luci_config/server/cfgclient/backend/format/format.go
index a77809d..31da089 100644
--- a/luci_config/server/cfgclient/backend/format/format.go
+++ b/luci_config/server/cfgclient/backend/format/format.go
@@ -37,14 +37,12 @@
if !p.FormatSpec.Unformatted() {
formatter, err := getFormatter(p.FormatSpec.Formatter)
if err != nil {
- return nil, errors.Annotate(err).Reason("failed to get formatter for %(format)q").
- D("format", p.FormatSpec).Err()
+ return nil, errors.Annotate(err, "failed to get formatter for %q", p.FormatSpec).Err()
}
if err := b.formatItem(item, formatter, p.FormatSpec); err != nil {
- return nil, errors.Annotate(err).Reason("failed to format item to %(format)q, data %(data)q").
- D("format", p.FormatSpec.Formatter).
- D("data", p.FormatSpec.Data).Err()
+ return nil, errors.Annotate(err, "failed to format item to %q, data %q",
+ p.FormatSpec.Formatter, p.FormatSpec.Data).Err()
}
}
return item, nil
@@ -62,9 +60,8 @@
if !p.FormatSpec.Unformatted() {
formatter, err := getFormatter(p.FormatSpec.Formatter)
if err != nil {
- return nil, errors.Annotate(err).Reason("failed to get formatter for %(format)q, data %(data)q").
- D("format", p.FormatSpec.Formatter).
- D("data", p.FormatSpec.Data).Err()
+ return nil, errors.Annotate(err, "failed to get formatter for %q, data %q",
+ p.FormatSpec.Formatter, p.FormatSpec.Data).Err()
}
lme := errors.NewLazyMultiError(len(items))
@@ -75,9 +72,8 @@
}
if err := lme.Get(); err != nil {
- return nil, errors.Annotate(err).Reason("failed to format items to %(format)q, data %(data)q").
- D("format", p.FormatSpec.Formatter).
- D("data", p.FormatSpec.Data).Err()
+ return nil, errors.Annotate(err, "failed to format items to %q, data %q",
+ p.FormatSpec.Formatter, p.FormatSpec.Data).Err()
}
}
return items, nil
@@ -92,7 +88,7 @@
// Item is not formatted, so format it.
content, err := formatter.FormatItem(it.Content, fs.Data)
if err != nil {
- return errors.Annotate(err).Reason("failed to format item").Err()
+ return errors.Annotate(err, "failed to format item").Err()
}
it.Content = content
it.FormatSpec = fs
diff --git a/luci_config/server/cfgclient/backend/format/formatters.go b/luci_config/server/cfgclient/backend/format/formatters.go
index 587a410..25a5386 100644
--- a/luci_config/server/cfgclient/backend/format/formatters.go
+++ b/luci_config/server/cfgclient/backend/format/formatters.go
@@ -64,7 +64,7 @@
formatter := registry.r[f]
if formatter == nil {
- return nil, errors.Reason("unknown formatter: %(formatter)q").D("formatter", f).Err()
+ return nil, errors.Reason("unknown formatter: %q", f).Err()
}
return formatter, nil
}
diff --git a/luci_config/server/cfgclient/backend/get_all.go b/luci_config/server/cfgclient/backend/get_all.go
index a789e85..3d5b156 100644
--- a/luci_config/server/cfgclient/backend/get_all.go
+++ b/luci_config/server/cfgclient/backend/get_all.go
@@ -36,7 +36,7 @@
case GetAllRef:
return refJSON, nil
default:
- return nil, errors.Reason("unknown GetAllTarget: %(value)v").D("value", gat).Err()
+ return nil, errors.Reason("unknown GetAllTarget: %v", gat).Err()
}
}
@@ -48,7 +48,7 @@
case bytes.Equal(d, refJSON):
*gat = GetAllRef
default:
- return errors.Reason("unknown GetAllTarget: %(value)q").D("value", d).Err()
+ return errors.Reason("unknown GetAllTarget: %q", d).Err()
}
return nil
}
diff --git a/luci_config/server/cfgclient/resolver.go b/luci_config/server/cfgclient/resolver.go
index 657f590..248fa14 100644
--- a/luci_config/server/cfgclient/resolver.go
+++ b/luci_config/server/cfgclient/resolver.go
@@ -50,7 +50,7 @@
func assertEmptyFormat(it *backend.Item) error {
if !it.FormatSpec.Unformatted() {
- return errors.Reason("unknown format: %(format)q").D("format", it.FormatSpec.Formatter).Err()
+ return errors.Reason("unknown format: %q", it.FormatSpec.Formatter).Err()
}
return nil
}
diff --git a/luci_config/server/cfgclient/textproto/resolver.go b/luci_config/server/cfgclient/textproto/resolver.go
index 7cc7996..10f57f2 100644
--- a/luci_config/server/cfgclient/textproto/resolver.go
+++ b/luci_config/server/cfgclient/textproto/resolver.go
@@ -81,7 +81,7 @@
v := reflect.ValueOf(out)
if !r.loadMulti(v) {
- panic(errors.Reason("%(type)s is not a pointer to a slice of protobuf message types").D("type", v.Type()).Err())
+ panic(errors.Reason("%s is not a pointer to a slice of protobuf message types", v.Type()).Err())
}
return &r
}
@@ -144,18 +144,18 @@
case "":
// Not formatted (text protobuf).
if err := luciProto.UnmarshalTextML(content, out); err != nil {
- return errors.Annotate(err).Reason("failed to unmarshal text protobuf").Err()
+ return errors.Annotate(err, "failed to unmarshal text protobuf").Err()
}
return nil
case BinaryFormat:
if err := parseBinaryContent(content, out); err != nil {
- return errors.Annotate(err).Reason("failed to unmarshal binary protobuf").Err()
+ return errors.Annotate(err, "failed to unmarshal binary protobuf").Err()
}
return nil
default:
- return errors.Reason("unsupported content format: %(format)q").D("format", format).Err()
+ return errors.Reason("unsupported content format: %q", format).Err()
}
}
@@ -174,20 +174,19 @@
func (f *Formatter) FormatItem(c, fd string) (string, error) {
archetype := proto.MessageType(fd)
if archetype == nil {
- return "", errors.Reason("unknown proto.Message type %(type)q in formatter data").
- D("type", fd).Err()
+ return "", errors.Reason("unknown proto.Message type %q in formatter data", fd).Err()
}
msg := archetypeMessage(archetype)
// Convert from config to protobuf.
if err := luciProto.UnmarshalTextML(c, msg); err != nil {
- return "", errors.Annotate(err).Reason("failed to unmarshal text protobuf content").Err()
+ return "", errors.Annotate(err, "failed to unmarshal text protobuf content").Err()
}
// Binary format.
bc, err := makeBinaryContent(msg)
if err != nil {
- return "", errors.Annotate(err).Err()
+ return "", errors.Annotate(err, "").Err()
}
return bc, nil
}
@@ -210,15 +209,15 @@
func makeBinaryContent(msg proto.Message) (string, error) {
d, err := proto.Marshal(msg)
if err != nil {
- return "", errors.Annotate(err).Reason("failed to marshal message").Err()
+ return "", errors.Annotate(err, "failed to marshal message").Err()
}
var buf bytes.Buffer
if _, err := cmpbin.WriteString(&buf, proto.MessageName(msg)); err != nil {
- return "", errors.Annotate(err).Reason("failed to write message name").Err()
+ return "", errors.Annotate(err, "failed to write message name").Err()
}
if _, err := cmpbin.WriteBytes(&buf, d); err != nil {
- return "", errors.Annotate(err).Reason("failed to write binary message content").Err()
+ return "", errors.Annotate(err, "failed to write binary message content").Err()
}
return buf.String(), nil
}
@@ -233,22 +232,21 @@
r := strings.NewReader(v)
encName, _, err := cmpbin.ReadString(r)
if err != nil {
- return errors.Annotate(err).Reason("failed to read message name").Err()
+ return errors.Annotate(err, "failed to read message name").Err()
}
// Construct a message for this.
if name := proto.MessageName(msg); name != encName {
- return errors.Reason("message name %(name)q doesn't match encoded name %(enc)q").
- D("name", name).D("enc", encName).Err()
+ return errors.Reason("message name %q doesn't match encoded name %q", name, encName).Err()
}
// We have the right message, unmarshal.
d, _, err := cmpbin.ReadBytes(r)
if err != nil {
- return errors.Annotate(err).Reason("failed to read binary message content").Err()
+ return errors.Annotate(err, "failed to read binary message content").Err()
}
if err := proto.Unmarshal(d, msg); err != nil {
- return errors.Annotate(err).Reason("failed to unmarshal message").Err()
+ return errors.Annotate(err, "failed to unmarshal message").Err()
}
return nil
}
diff --git a/lucictx/lucictx.go b/lucictx/lucictx.go
index dd9bb7b..d42cd91 100644
--- a/lucictx/lucictx.go
+++ b/lucictx/lucictx.go
@@ -175,7 +175,7 @@
// may have secrets.
f, err := ioutil.TempFile(dir, "luci_context.")
if err != nil {
- return nil, errors.Annotate(err).Reason("creating luci_context file").Err()
+ return nil, errors.Annotate(err, "creating luci_context file").Err()
}
l := &liveExport{path: f.Name()}
@@ -184,7 +184,7 @@
f.Close() // intentionally do this even on error.
if err != nil {
l.Close() // cleans up the tempfile
- return nil, errors.Annotate(err).Reason("writing luci_context").Err()
+ return nil, errors.Annotate(err, "writing luci_context").Err()
}
return l, nil
}
diff --git a/milo/build_source/raw_presentation/html.go b/milo/build_source/raw_presentation/html.go
index 2021a28..a6bc384 100644
--- a/milo/build_source/raw_presentation/html.go
+++ b/milo/build_source/raw_presentation/html.go
@@ -87,9 +87,7 @@
case defaultLogDogHost, "luci-logdog-dev.appspot.com":
return host, nil
default:
- return "", errors.Reason("host %(host)q is not whitelisted").
- D("host", host).
- Err()
+ return "", errors.Reason("host %q is not whitelisted", host).Err()
}
}
diff --git a/milo/build_source/swarming/build.go b/milo/build_source/swarming/build.go
index c4a7c9d..bb89330 100644
--- a/milo/build_source/swarming/build.go
+++ b/milo/build_source/swarming/build.go
@@ -506,7 +506,7 @@
}
client, err := fn(c, addr.Host)
if err != nil {
- return nil, errors.Annotate(err).Reason("failed to create LogDog client").Err()
+ return nil, errors.Annotate(err, "failed to create LogDog client").Err()
}
as := raw_presentation.AnnotationStream{
@@ -515,7 +515,7 @@
Path: addr.Path,
}
if err := as.Normalize(); err != nil {
- return nil, errors.Annotate(err).Reason("failed to normalize annotation stream parameters").Err()
+ return nil, errors.Annotate(err, "failed to normalize annotation stream parameters").Err()
}
return &as, nil
@@ -602,7 +602,7 @@
// If the LogDog stream is available, load the step from that.
as, err := bl.newEmptyAnnotationStream(c, logDogStreamAddr)
if err != nil {
- return nil, errors.Annotate(err).Reason("failed to create LogDog annotation stream").Err()
+ return nil, errors.Annotate(err, "failed to create LogDog annotation stream").Err()
}
prefix, _ := logDogStreamAddr.Path.Split()
diff --git a/milo/build_source/swarming/buildinfo.go b/milo/build_source/swarming/buildinfo.go
index 0f7361d..795c1bb 100644
--- a/milo/build_source/swarming/buildinfo.go
+++ b/milo/build_source/swarming/buildinfo.go
@@ -220,26 +220,23 @@
// Gather our Swarming task template parameters and perform a substitution.
runID, err := getRunID(taskID, tryNumber)
if err != nil {
- return nil, errors.Annotate(err).Err()
+ return nil, errors.Annotate(err, "").Err()
}
p := tasktemplate.Params{
SwarmingRunID: runID,
}
if logLocation, err = p.Resolve(logLocation); err != nil {
- return nil, errors.Annotate(err).Reason("failed to resolve swarming task templating in 'log_location'").Err()
+ return nil, errors.Annotate(err, "failed to resolve swarming task templating in 'log_location'").Err()
}
addr, err := types.ParseURL(logLocation)
if err != nil {
- return nil, errors.Annotate(err).Reason("could not parse LogDog stream from location").Err()
+ return nil, errors.Annotate(err, "could not parse LogDog stream from location").Err()
}
// The LogDog stream's project should match the LUCI project.
if string(addr.Project) != luciProject {
- return nil, errors.Reason("stream project %(streamProject)q doesn't match LUCI project %(luciProject)q").
- D("luciProject", luciProject).
- D("streamProject", addr.Project).
- Err()
+ return nil, errors.Reason("stream project %q doesn't match LUCI project %q", addr.Project, luciProject).Err()
}
return addr, nil
@@ -259,17 +256,13 @@
// Parse "tryNumber" as a hex string.
if tryNumber < 0 || tryNumber > 0x0F {
- return "", errors.Reason("try number %(try)d exceeds 4 bits").
- D("try", tryNumber).
- Err()
+ return "", errors.Reason("try number %d exceeds 4 bits", tryNumber).Err()
}
lastChar, lastCharSize := utf8.DecodeLastRuneInString(taskID)
v, err := strconv.ParseUint(string(lastChar), 16, 8)
if err != nil {
- return "", errors.Annotate(err).Reason("failed to parse hex from rune: %(rune)r").
- D("rune", lastChar).
- Err()
+ return "", errors.Annotate(err, "failed to parse hex from rune: %r", lastChar).Err()
}
return taskID[:len(taskID)-lastCharSize] + strconv.FormatUint((v|uint64(tryNumber)), 16), nil
diff --git a/tokenserver/appengine/impl/certconfig/rpc_fetch_crl.go b/tokenserver/appengine/impl/certconfig/rpc_fetch_crl.go
index 6d6e426..5b78a32 100644
--- a/tokenserver/appengine/impl/certconfig/rpc_fetch_crl.go
+++ b/tokenserver/appengine/impl/certconfig/rpc_fetch_crl.go
@@ -142,8 +142,8 @@
// Transient error?
if resp.StatusCode >= http.StatusInternalServerError {
logging.Warningf(c, "GET %s - HTTP %d; %q", cfg.CrlUrl, resp.StatusCode, string(blob))
- return nil, "", errors.Reason("server replied with HTTP %(code)d").
- D("code", resp.StatusCode).Tag(transient.Tag).Err()
+ return nil, "", errors.Reason("server replied with HTTP %d", resp.StatusCode).
+ Tag(transient.Tag).Err()
}
// Something we don't support or expect?
diff --git a/tokenserver/appengine/impl/utils/policy/policy.go b/tokenserver/appengine/impl/utils/policy/policy.go
index 3f936b9..e8b7d21 100644
--- a/tokenserver/appengine/impl/utils/policy/policy.go
+++ b/tokenserver/appengine/impl/utils/policy/policy.go
@@ -123,7 +123,7 @@
err = errors.New("no configs fetched by the callback")
}
if err != nil {
- return "", errors.Annotate(err).Reason("failed to fetch policy configs").Err()
+ return "", errors.Annotate(err, "failed to fetch policy configs").Err()
}
rev = fetcher.Revision()
@@ -132,7 +132,7 @@
// SHA256 digest).
cfgBlob, err := serializeBundle(bundle)
if err != nil {
- return "", errors.Annotate(err).Reason("failed to serialize the configs").Err()
+ return "", errors.Annotate(err, "failed to serialize the configs").Err()
}
digest := sha256.Sum256(cfgBlob)
digestHex := hex.EncodeToString(digest[:])
@@ -141,7 +141,7 @@
// Do we have it already?
existingHdr, err := getImportedPolicyHeader(c, p.Name)
if err != nil {
- return "", errors.Annotate(err).Reason("failed to grab ImportedPolicyHeader").Err()
+ return "", errors.Annotate(err, "failed to grab ImportedPolicyHeader").Err()
}
if existingHdr != nil && digestHex == existingHdr.SHA256 {
logging.Infof(
@@ -160,9 +160,7 @@
v := validation.Context{Logger: logging.Get(c)}
p.Validate(bundle, &v)
if err := v.Finalize(); err != nil {
- return "", errors.Annotate(err).
- Reason("configs at rev %(rev)s are invalid").
- D("rev", rev).Err()
+ return "", errors.Annotate(err, "configs at rev %s are invalid", rev).Err()
}
}
@@ -173,7 +171,7 @@
err = errors.New("wrong revision in result of Prepare callback")
}
if err != nil {
- return "", errors.Annotate(err).Reason("failed to convert configs into a queryable form").Err()
+ return "", errors.Annotate(err, "failed to convert configs into a queryable form").Err()
}
logging.Infof(c, "Storing new configs")
@@ -210,7 +208,7 @@
hdr, err := getImportedPolicyHeader(c, p.Name)
switch {
case err != nil:
- err = errors.Annotate(err).Reason("failed to fetch importedPolicyHeader entity").Err()
+ err = errors.Annotate(err, "failed to fetch importedPolicyHeader entity").Err()
return
case hdr == nil:
err = ErrNoPolicy
@@ -231,7 +229,7 @@
body, err := getImportedPolicyBody(c, p.Name)
switch {
case err != nil:
- err = errors.Annotate(err).Reason("failed to fetch importedPolicyBody entity").Err()
+ err = errors.Annotate(err, "failed to fetch importedPolicyBody entity").Err()
return
case body == nil: // this is rare, the body shouldn't disappear
logging.Errorf(c, "The policy body is unexpectedly gone")
@@ -249,7 +247,7 @@
logging.Infof(c, "Using configs at rev %s", body.Revision)
configs, unknown, err := deserializeBundle(body.Data)
if err != nil {
- err = errors.Annotate(err).Reason("failed to deserialize cached configs").Err()
+ err = errors.Annotate(err, "failed to deserialize cached configs").Err()
return
}
if len(unknown) != 0 {
@@ -261,7 +259,7 @@
}
queryable, err := p.Prepare(configs, body.Revision)
if err != nil {
- err = errors.Annotate(err).Reason("failed to process cached configs").Err()
+ err = errors.Annotate(err, "failed to process cached configs").Err()
return
}
diff --git a/tools/cmd/gorun/main.go b/tools/cmd/gorun/main.go
index 1416b67..dc0dd85 100644
--- a/tools/cmd/gorun/main.go
+++ b/tools/cmd/gorun/main.go
@@ -25,14 +25,14 @@
func mainImpl(args []string) (int, error) {
if len(args) < 1 {
- return 1, errors.Reason("accepts one argument: package").Err()
+ return 1, errors.New("accepts one argument: package")
}
pkg, args := args[0], args[1:]
// Create a temporary output directory to build into.
tmpdir, err := ioutil.TempDir("", "luci-gorun")
if err != nil {
- return 1, errors.Annotate(err).Reason("failed to create temporary directory").Err()
+ return 1, errors.Annotate(err, "failed to create temporary directory").Err()
}
defer os.RemoveAll(tmpdir)
@@ -46,7 +46,7 @@
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if err := cmd.Run(); err != nil {
- return 1, errors.Annotate(err).Reason("failed to build: %(package)s").D("package", pkg).Err()
+ return 1, errors.Annotate(err, "failed to build: %s", pkg).Err()
}
// Run the package.
@@ -58,7 +58,7 @@
if rc, ok := exitcode.Get(err); ok {
return rc, nil
}
- return 1, errors.Annotate(err).Reason("failed to run: %(package)s").D("package", pkg).Err()
+ return 1, errors.Annotate(err, "failed to run: %s", pkg).Err()
}
return 0, nil
@@ -67,7 +67,9 @@
func main() {
rc, err := mainImpl(os.Args[1:])
if err != nil {
- _, _ = errors.RenderStack(err).DumpTo(os.Stderr)
+ for _, line := range errors.RenderStack(err) {
+ os.Stderr.WriteString(line + "\n")
+ }
}
os.Exit(rc)
}
diff --git a/vpython/application/application.go b/vpython/application/application.go
index ded8af1..e520237 100644
--- a/vpython/application/application.go
+++ b/vpython/application/application.go
@@ -167,7 +167,7 @@
} else {
hdir, err := homedir.Dir()
if err != nil {
- return errors.Annotate(err).Reason("failed to get user home directory").Err()
+ return errors.Annotate(err, "failed to get user home directory").Err()
}
a.opts.EnvConfig.BaseDir = filepath.Join(hdir, ".vpython")
}
@@ -179,7 +179,7 @@
a.addToFlagSet(fs)
selfArgs, args := extractFlagsForSet(args, fs)
if err := fs.Parse(selfArgs); err != nil && err != flag.ErrHelp {
- return errors.Annotate(err).Reason("failed to parse flags").Err()
+ return errors.Annotate(err, "failed to parse flags").Err()
}
// Identify the "self" executable. Use this to construct a "lookPath", which
@@ -210,10 +210,8 @@
a.opts.EnvConfig.Spec = &sp
} else if specPath := a.opts.Environ.GetEmpty(DefaultSpecENV); specPath != "" {
if err := spec.Load(specPath, &a.opts.DefaultSpec); err != nil {
- return errors.Annotate(err).
- Reason("failed to load default specification file ("+DefaultSpecENV+"from: %(path)s").
- D("path", specPath).
- Err()
+ return errors.Annotate(err, "failed to load default specification file (%s) from %s",
+ DefaultSpecENV, specPath).Err()
}
}
@@ -222,7 +220,7 @@
if a.opts.EnvConfig.BaseDir == "" {
tdir, err := ioutil.TempDir("", "vpython")
if err != nil {
- return errors.Annotate(err).Reason("failed to create temporary directory").Err()
+ return errors.Annotate(err, "failed to create temporary directory").Err()
}
defer func() {
logging.Debugf(c, "Removing temporary directory: %s", tdir)
@@ -246,7 +244,7 @@
err = ReturnCodeError(rc)
}
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
}
return nil
}
@@ -267,7 +265,7 @@
i, err := python.Find(c, python.Version{}, lp.look)
if err != nil {
- return errors.Annotate(err).Reason("could not find Python interpreter for help").Err()
+ return errors.Annotate(err, "could not find Python interpreter for help").Err()
}
// Redirect all "--help" to Stdout for consistency.
@@ -276,9 +274,7 @@
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stdout
if err := cmd.Run(); err != nil {
- return errors.Annotate(err).Reason("failed to dump Python help from: %(interpreter)s").
- D("interpreter", i.Python).
- Err()
+ return errors.Annotate(err, "failed to dump Python help from: %s", i.Python).Err()
}
return nil
}
diff --git a/vpython/application/probe.go b/vpython/application/probe.go
index a12713e..2f0bdb2 100644
--- a/vpython/application/probe.go
+++ b/vpython/application/probe.go
@@ -104,9 +104,7 @@
output, err := cmd.CombinedOutput()
rc, ok := exitcode.Get(err)
if !ok {
- err = errors.Annotate(err).Reason("failed to check if %(path)q is a wrapper").
- D("path", path).
- Err()
+ err = errors.Annotate(err, "failed to check if %q is a wrapper", path).Err()
return
}
@@ -130,7 +128,7 @@
// The target returned non-zero, but didn't identify as a wrapper. It is
// likely something that happens to be named the same thing as the target,
// which is an error.
- err = errors.Annotate(err).Reason("wrapper check returned non-zero").Err()
+ err = errors.Annotate(err, "wrapper check returned non-zero").Err()
}
return
diff --git a/vpython/application/subcommand_delete.go b/vpython/application/subcommand_delete.go
index 7f387d3..b2b6117 100644
--- a/vpython/application/subcommand_delete.go
+++ b/vpython/application/subcommand_delete.go
@@ -70,9 +70,7 @@
}
if failures > 0 {
- return errors.Reason("failed to delete %(count)d environment(s)").
- D("count", failures).
- Err()
+ return errors.Reason("failed to delete %d environment(s)", failures).Err()
}
return nil
})
diff --git a/vpython/application/subcommand_install.go b/vpython/application/subcommand_install.go
index 8e60d9a..0de056e 100644
--- a/vpython/application/subcommand_install.go
+++ b/vpython/application/subcommand_install.go
@@ -50,7 +50,7 @@
return nil
})
if err != nil {
- return errors.Annotate(err).Reason("failed to setup the environment").Err()
+ return errors.Annotate(err, "failed to setup the environment").Err()
}
logging.Infof(c, "Successfully setup the environment.")
diff --git a/vpython/application/subcommand_verify.go b/vpython/application/subcommand_verify.go
index 47e7e50..6fd3831 100644
--- a/vpython/application/subcommand_verify.go
+++ b/vpython/application/subcommand_verify.go
@@ -40,7 +40,7 @@
return run(c, func(c context.Context) error {
// Make sure that we can resolve the referenced specifiction.
if err := a.opts.ResolveSpec(c); err != nil {
- return errors.Annotate(err).Reason("failed to resolve specification").Err()
+ return errors.Annotate(err, "failed to resolve specification").Err()
}
s := a.opts.EnvConfig.Spec
@@ -54,7 +54,7 @@
// Verify that the spec can be normalized. This may modify it, so we will
// normalize a clone.
if err := spec.NormalizeSpec(s.Clone(), nil); err != nil {
- return errors.Annotate(err).Reason("failed to normalize specification").Err()
+ return errors.Annotate(err, "failed to normalize specification").Err()
}
renderedSpec := spec.Render(s)
diff --git a/vpython/cipd/cipd.go b/vpython/cipd/cipd.go
index e0e5088..b7cb757 100644
--- a/vpython/cipd/cipd.go
+++ b/vpython/cipd/cipd.go
@@ -61,7 +61,7 @@
if pl.Template != nil {
loaderTemplate, err := pl.Template(c, e)
if err != nil {
- return errors.Annotate(err).Reason("failed to get CIPD template arguments").Err()
+ return errors.Annotate(err, "failed to get CIPD template arguments").Err()
}
for k, v := range loaderTemplate {
template[k] = v
@@ -115,7 +115,7 @@
client, err := cipd.NewClient(opts)
if err != nil {
- return errors.Annotate(err).Reason("failed to generate CIPD client").Err()
+ return errors.Annotate(err, "failed to generate CIPD client").Err()
}
// Start a CIPD client batch.
@@ -126,10 +126,7 @@
resolved, err := ef.ResolveWith(func(pkg, vers string) (common.Pin, error) {
pin, err := client.ResolveVersion(c, pkg, vers)
if err != nil {
- return pin, errors.Annotate(err).Reason("failed to resolve package %(package)q at version %(version)q").
- D("package", pkg).
- D("version", vers).
- Err()
+ return pin, errors.Annotate(err, "failed to resolve package %q at version %q", pkg, vers).Err()
}
logging.Fields{
@@ -161,7 +158,7 @@
func (pl *PackageLoader) Ensure(c context.Context, root string, packages []*vpython.Spec_Package) error {
pins, err := packagesToPins(packages)
if err != nil {
- return errors.Annotate(err).Reason("failed to convert packages to CIPD pins").Err()
+ return errors.Annotate(err, "failed to convert packages to CIPD pins").Err()
}
pinSlice := common.PinSliceBySubdir{
"": pins,
@@ -172,7 +169,7 @@
opts.Root = root
client, err := cipd.NewClient(opts)
if err != nil {
- return errors.Annotate(err).Reason("failed to generate CIPD client").Err()
+ return errors.Annotate(err, "failed to generate CIPD client").Err()
}
// Start a CIPD client batch.
@@ -181,7 +178,7 @@
actionMap, err := client.EnsurePackages(c, pinSlice, false)
if err != nil {
- return errors.Annotate(err).Reason("failed to install CIPD packages").Err()
+ return errors.Annotate(err, "failed to install CIPD packages").Err()
}
if len(actionMap) > 0 {
errorCount := 0
@@ -192,9 +189,7 @@
}
}
if errorCount > 0 {
- return errors.Reason("CIPD package installation encountered %(count)d error(s)").
- D("count", errorCount).
- Err()
+ return errors.Reason("CIPD package installation encountered %d error(s)", errorCount).Err()
}
}
return nil
diff --git a/vpython/options.go b/vpython/options.go
index 8d7e953..597b3d9 100644
--- a/vpython/options.go
+++ b/vpython/options.go
@@ -60,17 +60,17 @@
if o.WorkDir == "" {
wd, err := os.Getwd()
if err != nil {
- return errors.Annotate(err).Reason("failed to get working directory").Err()
+ return errors.Annotate(err, "failed to get working directory").Err()
}
o.WorkDir = wd
}
if err := filesystem.AbsPath(&o.WorkDir); err != nil {
- return errors.Annotate(err).Reason("failed to resolve absolute path of WorkDir").Err()
+ return errors.Annotate(err, "failed to resolve absolute path of WorkDir").Err()
}
// Resolve our target python script.
if err := o.ResolveSpec(c); err != nil {
- return errors.Annotate(err).Reason("failed to resolve Python script").Err()
+ return errors.Annotate(err, "failed to resolve Python script").Err()
}
// If no environment base directory was supplied, create one under the current
@@ -80,9 +80,7 @@
if v, ok := o.Environ.Get(EnvironmentStampPathENV); ok {
var err error
if o.EnvConfig.BaseDir, err = venv.EnvRootFromStampPath(v); err != nil {
- return errors.Annotate(err).Reason("failed to get env root from environment: %(path)s").
- D("path", v).
- Err()
+ return errors.Annotate(err, "failed to get env root from environment: %s", v).Err()
}
logging.Debugf(c, "Loaded environment root from environment variable: %s", o.EnvConfig.BaseDir)
}
@@ -102,7 +100,7 @@
// invoked with.
cmd, err := python.ParseCommandLine(o.Args)
if err != nil {
- return errors.Annotate(err).Reason("failed to parse Python command-line").Err()
+ return errors.Annotate(err, "failed to parse Python command-line").Err()
}
// If we're running a Python script, assert that the target script exists.
@@ -114,17 +112,13 @@
// Resolve to absolute script path.
if err := filesystem.AbsPath(&script.Path); err != nil {
- return errors.Annotate(err).Reason("failed to get absolute path of: %(path)s").
- D("path", cmd.Target).
- Err()
+ return errors.Annotate(err, "failed to get absolute path of: %s", cmd.Target).Err()
}
// Confirm that the script path actually exists.
st, err := os.Stat(script.Path)
if err != nil {
- return errors.Annotate(err).Reason("failed to stat Python script: %(path)s").
- D("path", cmd.Target).
- Err()
+ return errors.Annotate(err, "failed to stat Python script: %s", cmd.Target).Err()
}
// If the script is a directory, then we assume that we're doing a module
@@ -136,10 +130,8 @@
if isScriptTarget {
spec, err := o.SpecLoader.LoadForScript(c, script.Path, isModule)
if err != nil {
- return errors.Annotate(err).Reason("failed to load spec for script: %(path)s").
- D("path", cmd.Target).
- D("isModule", isModule).
- Err()
+ return errors.Annotate(err, "failed to load spec for script: %s", cmd.Target).
+ InternalReason("isModule(%v)", isModule).Err()
}
if spec != nil {
o.EnvConfig.Spec = spec
@@ -151,9 +143,7 @@
if v, ok := o.Environ.Get(EnvironmentStampPathENV); ok {
var sp vpython.Spec
if err := spec.Load(v, &sp); err != nil {
- return errors.Annotate(err).Reason("failed to load environment-supplied spec from: %(path)s").
- D("path", v).
- Err()
+ return errors.Annotate(err, "failed to load environment-supplied spec from: %s", v).Err()
}
logging.Infof(c, "Loaded spec from environment: %s", v)
diff --git a/vpython/python/find.go b/vpython/python/find.go
index e9c0f27..8f8451b 100644
--- a/vpython/python/find.go
+++ b/vpython/python/find.go
@@ -69,7 +69,7 @@
}
// No Python interpreter could be identified.
- return nil, errors.Annotate(lookErrs.Get()).Reason("no Python found").Err()
+ return nil, errors.Annotate(lookErrs.Get(), "no Python found").Err()
}
func findInterpreter(c context.Context, name string, vers Version, lookPath LookPathFunc) (*Interpreter, error) {
@@ -78,9 +78,7 @@
}
lpr, err := lookPath(c, name)
if err != nil {
- return nil, errors.Annotate(err).Reason("could not find executable for: %(name)q").
- D("name", name).
- Err()
+ return nil, errors.Annotate(err, "could not find executable for: %q", name).Err()
}
i := Interpreter{
@@ -102,16 +100,10 @@
iv, err := i.GetVersion(c)
if err != nil {
- return nil, errors.Annotate(err).Reason("failed to get version for: %(interp)q").
- D("interp", i.Python).
- Err()
+ return nil, errors.Annotate(err, "failed to get version for: %q", i.Python).Err()
}
if !vers.IsSatisfiedBy(iv) {
- return nil, errors.Reason("interpreter %(interp)q version %(interpVersion)q does not satisfy %(version)q").
- D("interp", i.Python).
- D("interpVersion", iv).
- D("version", vers).
- Err()
+ return nil, errors.Reason("interpreter %q version %q does not satisfy %q", i.Python, iv, vers).Err()
}
return &i, nil
diff --git a/vpython/python/interpreter.go b/vpython/python/interpreter.go
index bc8e5f7..137429f 100644
--- a/vpython/python/interpreter.go
+++ b/vpython/python/interpreter.go
@@ -50,9 +50,7 @@
}
resolved, err := filepath.EvalSymlinks(i.Python)
if err != nil {
- return errors.Annotate(err).Reason("could not evaluate symlinks for: %(path)q").
- D("path", i.Python).
- Err()
+ return errors.Annotate(err, "could not evaluate symlinks for: %q", i.Python).Err()
}
i.Python = resolved
return nil
@@ -98,7 +96,7 @@
cmd := i.IsolatedCommand(c, "--version")
out, err := cmd.CombinedOutput()
if err != nil {
- err = errors.Annotate(err).Err()
+ err = errors.Annotate(err, "").Err()
return
}
@@ -118,15 +116,13 @@
hashInterpreter := func(path string) (string, error) {
fd, err := os.Open(i.Python)
if err != nil {
- return "", errors.Annotate(err).Reason("failed to open interpreter").Err()
+ return "", errors.Annotate(err, "failed to open interpreter").Err()
}
defer fd.Close()
hash := sha256.New()
if _, err := io.Copy(hash, fd); err != nil {
- return "", errors.Annotate(err).Reason("failed to read [%(path)s] for hashing").
- D("path", path).
- Err()
+ return "", errors.Annotate(err, "failed to read [%s] for hashing", path).Err()
}
return hex.EncodeToString(hash.Sum(nil)), nil
@@ -148,15 +144,12 @@
parts := strings.SplitN(s, " ", 2)
if len(parts) != 2 || parts[0] != "Python" {
return Version{}, errors.Reason("unknown version output").
- D("output", s).
- Err()
+ InternalReason("output(%q)", s).Err()
}
v, err := ParseVersion(parts[1])
if err != nil {
- err = errors.Annotate(err).Reason("failed to parse version from: %(value)q").
- D("value", parts[1]).
- Err()
+ err = errors.Annotate(err, "failed to parse version from: %q", parts[1]).Err()
return v, err
}
return v, nil
diff --git a/vpython/python/python.go b/vpython/python/python.go
index 6855af2..ca30b69 100644
--- a/vpython/python/python.go
+++ b/vpython/python/python.go
@@ -104,7 +104,7 @@
// Extract the flag Target. -f<lag>
r, l := utf8.DecodeRuneInString(flag)
if r == utf8.RuneError {
- err = errors.Reason("invalid rune in flag #%(index)d").D("index", i).Err()
+ err = errors.Reason("invalid rune in flag #%d", i).Err()
return
}
@@ -116,10 +116,7 @@
}
if i >= len(args) {
- return "", errors.Reason("two-value flag -%(flag)c missing second value at %(index)d").
- D("flag", r).
- D("index", i).
- Err()
+ return "", errors.Reason("two-value flag -%c missing second value at %d", r, i).Err()
}
value := args[i]
diff --git a/vpython/python/version.go b/vpython/python/version.go
index 30b448b..894809e 100644
--- a/vpython/python/version.go
+++ b/vpython/python/version.go
@@ -45,18 +45,14 @@
match := canonicalVersionRE.FindStringSubmatch(s)
if match == nil {
- return v, errors.Reason("non-canonical Python version string: %(value)q").
- D("value", s).
- Err()
+ return v, errors.Reason("non-canonical Python version string: %q", s).Err()
}
parts := strings.Split(match[2], ".")
parseVersion := func(value string) (int, error) {
version, err := strconv.Atoi(value)
if err != nil {
- return 0, errors.Annotate(err).Reason("invalid number value: %(value)q").
- D("value", value).
- Err()
+ return 0, errors.Annotate(err, "invalid number value: %q", value).Err()
}
return version, nil
}
@@ -66,16 +62,16 @@
var err error
if len(parts) >= 3 {
if v.Patch, err = parseVersion(parts[2]); err != nil {
- return v, errors.Annotate(err).Reason("invalid patch value").Err()
+ return v, errors.Annotate(err, "invalid patch value").Err()
}
}
if len(parts) >= 2 {
if v.Minor, err = parseVersion(parts[1]); err != nil {
- return v, errors.Annotate(err).Reason("invalid minor value").Err()
+ return v, errors.Annotate(err, "invalid minor value").Err()
}
}
if v.Major, err = parseVersion(parts[0]); err != nil {
- return v, errors.Annotate(err).Reason("invalid major value").Err()
+ return v, errors.Annotate(err, "invalid major value").Err()
}
if v.IsZero() {
return v, errors.Reason("version is incomplete").Err()
diff --git a/vpython/run.go b/vpython/run.go
index 1862d85..4266205 100644
--- a/vpython/run.go
+++ b/vpython/run.go
@@ -50,7 +50,7 @@
func Run(c context.Context, opts Options) error {
// Resolve our Options.
if err := opts.resolve(c); err != nil {
- return errors.Annotate(err).Reason("could not resolve options").Err()
+ return errors.Annotate(err, "could not resolve options").Err()
}
// Create a local cancellation option (signal handling).
@@ -99,12 +99,12 @@
// Output the Python command being executed.
if err := runAndForwardSignals(c, cmd, cancelFunc); err != nil {
- return errors.Annotate(err).Reason("failed to execute bootstrapped Python").Err()
+ return errors.Annotate(err, "failed to execute bootstrapped Python").Err()
}
return nil
})
if err != nil {
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
}
return nil
}
@@ -121,7 +121,7 @@
}()
if err := cmd.Start(); err != nil {
- return errors.Annotate(err).Reason("failed to start process").Err()
+ return errors.Annotate(err, "failed to start process").Err()
}
logging.Fields{
@@ -149,7 +149,7 @@
err := cmd.Wait()
logging.Debugf(c, "Python subprocess has terminated: %v", err)
if err != nil {
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
}
return nil
}
diff --git a/vpython/spec/load.go b/vpython/spec/load.go
index 351527f..7181b64 100644
--- a/vpython/spec/load.go
+++ b/vpython/spec/load.go
@@ -45,9 +45,7 @@
func Load(path string, spec *vpython.Spec) error {
content, err := ioutil.ReadFile(path)
if err != nil {
- return errors.Annotate(err).Reason("failed to load file from: %(path)s").
- D("path", path).
- Err()
+ return errors.Annotate(err, "failed to load file from: %s", path).Err()
}
return Parse(string(content), spec)
@@ -56,7 +54,7 @@
// Parse loads a specification message from a content string.
func Parse(content string, spec *vpython.Spec) error {
if err := cproto.UnmarshalTextML(content, spec); err != nil {
- return errors.Annotate(err).Reason("failed to unmarshal vpython.Spec").Err()
+ return errors.Annotate(err, "failed to unmarshal vpython.Spec").Err()
}
return nil
}
@@ -158,7 +156,7 @@
// Partner File: Try loading the spec from an adjacent file.
specPath, err := l.findForScript(path, isModule)
if err != nil {
- return nil, errors.Annotate(err).Reason("failed to scan for filesystem spec").Err()
+ return nil, errors.Annotate(err, "failed to scan for filesystem spec").Err()
}
if specPath != "" {
var spec vpython.Spec
@@ -178,9 +176,7 @@
}
switch spec, err := l.parseFrom(mainScript); {
case err != nil:
- return nil, errors.Annotate(err).Reason("failed to parse inline spec from: %(script)s").
- D("script", mainScript).
- Err()
+ return nil, errors.Annotate(err, "failed to parse inline spec from: %s", mainScript).Err()
case spec != nil:
logging.Infof(c, "Loaded inline spec from: %s", mainScript)
@@ -228,9 +224,7 @@
// Not a Python module, so we're done our search.
return "", nil
}
- return "", errors.Annotate(err).Reason("failed to stat for: %(path)").
- D("path", initPath).
- Err()
+ return "", errors.Annotate(err, "failed to stat for: %s", path).Err()
}
// Does a spec file exist for this path?
@@ -249,9 +243,7 @@
}
default:
- return "", errors.Annotate(err).Reason("failed to check for spec file at: %(path)s").
- D("path", specPath).
- Err()
+ return "", errors.Annotate(err, "failed to check for spec file at: %s", specPath).Err()
}
}
}
@@ -259,7 +251,7 @@
func (l *Loader) parseFrom(path string) (*vpython.Spec, error) {
fd, err := os.Open(path)
if err != nil {
- return nil, errors.Annotate(err).Reason("failed to open file").Err()
+ return nil, errors.Annotate(err, "failed to open file").Err()
}
defer fd.Close()
@@ -296,7 +288,7 @@
}
}
if err := s.Err(); err != nil {
- return nil, errors.Annotate(err).Reason("error scanning file").Err()
+ return nil, errors.Annotate(err, "error scanning file").Err()
}
if len(content) == 0 {
return nil, nil
@@ -330,9 +322,7 @@
// Process the resulting file.
var spec vpython.Spec
if err := Parse(strings.Join(content, "\n"), &spec); err != nil {
- return nil, errors.Annotate(err).Reason("failed to parse spec file from: %(path)s").
- D("path", path).
- Err()
+ return nil, errors.Annotate(err, "failed to parse spec file from: %s", path).Err()
}
return &spec, nil
}
@@ -352,9 +342,7 @@
default:
// Failed to load specification from this file.
- return "", errors.Annotate(err).Reason("failed to stat common spec file at: %(path)s").
- D("path", checkPath).
- Err()
+ return "", errors.Annotate(err, "failed to stat common spec file at: %s", checkPath).Err()
}
// If we have any barrier files, check to see if they are present in this
diff --git a/vpython/spec/spec.go b/vpython/spec/spec.go
index a675f32..36db83a 100644
--- a/vpython/spec/spec.go
+++ b/vpython/spec/spec.go
@@ -70,9 +70,7 @@
// immediate repetitions.
for i, pkg := range spec.Wheel {
if i > 0 && pkg.Name == spec.Wheel[i-1].Name {
- return errors.Reason("duplicate spec entries for package %(path)q").
- D("name", pkg.Name).
- Err()
+ return errors.Reason("duplicate spec entries for package %q", pkg.Name).Err()
}
}
diff --git a/vpython/venv/config.go b/vpython/venv/config.go
index e68ad32..85c230d 100644
--- a/vpython/venv/config.go
+++ b/vpython/venv/config.go
@@ -140,7 +140,7 @@
logging.Debugf(c, "Using tempdir-relative environment root: %s", cfg.BaseDir)
}
if err := filesystem.AbsPath(&cfg.BaseDir); err != nil {
- return nil, errors.Annotate(err).Reason("failed to resolve absolute path of base directory").Err()
+ return nil, errors.Annotate(err, "failed to resolve absolute path of base directory").Err()
}
// Enforce maximum path length.
@@ -148,11 +148,10 @@
if longestPath := longestGeneratedScriptPath(cfg.BaseDir); longestPath != "" {
longestPathLen := utf8.RuneCountInString(longestPath)
if longestPathLen > cfg.MaxScriptPathLen {
- return nil, errors.Reason("expected deepest path length (%(len)d) exceeds threshold (%(threshold)d)").
- D("len", longestPathLen).
- D("threshold", cfg.MaxScriptPathLen).
- D("longestPath", longestPath).
- Err()
+ return nil, errors.Reason(
+ "expected deepest path length (%d) exceeds threshold (%d)",
+ longestPathLen, cfg.MaxScriptPathLen,
+ ).InternalReason("longestPath(%q)", longestPath).Err()
}
}
}
@@ -163,7 +162,7 @@
e.Spec = cfg.Spec.Clone()
}
if err := spec.NormalizeEnvironment(e); err != nil {
- return nil, errors.Annotate(err).Reason("invalid environment").Err()
+ return nil, errors.Annotate(err, "invalid environment").Err()
}
// If the environment doesn't specify a VirtualEnv package (expected), use
@@ -173,11 +172,11 @@
}
if err := cfg.Loader.Resolve(c, e); err != nil {
- return nil, errors.Annotate(err).Reason("failed to resolve packages").Err()
+ return nil, errors.Annotate(err, "failed to resolve packages").Err()
}
if err := cfg.resolvePythonInterpreter(c, e.Spec); err != nil {
- return nil, errors.Annotate(err).Reason("failed to resolve system Python interpreter").Err()
+ return nil, errors.Annotate(err, "failed to resolve system Python interpreter").Err()
}
e.Runtime.Path = cfg.si.Python
e.Runtime.Version = e.Spec.PythonVersion
@@ -191,9 +190,7 @@
// Ensure that our base directory exists.
if err := filesystem.MakeDirs(cfg.BaseDir); err != nil {
- return nil, errors.Annotate(err).Reason("could not create environment root: %(root)s").
- D("root", cfg.BaseDir).
- Err()
+ return nil, errors.Annotate(err, "could not create environment root: %s", cfg.BaseDir).Err()
}
// Generate our environment name based on the deterministic hash of its
@@ -220,7 +217,7 @@
// Config.
func (cfg *Config) Prune(c context.Context) error {
if err := prune(c, cfg, nil); err != nil {
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
}
return nil
}
@@ -250,18 +247,14 @@
func (cfg *Config) resolvePythonInterpreter(c context.Context, s *vpython.Spec) error {
specVers, err := python.ParseVersion(s.PythonVersion)
if err != nil {
- return errors.Annotate(err).Reason("failed to parse Python version from: %(value)q").
- D("value", s.PythonVersion).
- Err()
+ return errors.Annotate(err, "failed to parse Python version from: %q", s.PythonVersion).Err()
}
if cfg.Python == "" {
// No explicitly-specified Python path. Determine one based on the
// specification.
if cfg.si, err = python.Find(c, specVers, cfg.LookPathFunc); err != nil {
- return errors.Annotate(err).Reason("could not find Python for: %(vers)s").
- D("vers", specVers).
- Err()
+ return errors.Annotate(err, "could not find Python for: %s", specVers).Err()
}
cfg.Python = cfg.si.Python
} else {
@@ -277,23 +270,16 @@
// expected.
interpreterVers, err := cfg.si.GetVersion(c)
if err != nil {
- return errors.Annotate(err).Reason("failed to determine Python version for: %(python)s").
- D("python", cfg.Python).
- Err()
+ return errors.Annotate(err, "failed to determine Python version for: %s", cfg.Python).Err()
}
if !specVers.IsSatisfiedBy(interpreterVers) {
- return errors.Reason("supplied Python version (%(supplied)s) doesn't match specification (%(spec)s)").
- D("supplied", interpreterVers).
- D("spec", specVers).
- Err()
+ return errors.Reason("supplied Python version (%s) doesn't match specification (%s)", interpreterVers, specVers).Err()
}
s.PythonVersion = interpreterVers.String()
// Resolve to absolute path.
if err := filesystem.AbsPath(&cfg.Python); err != nil {
- return errors.Annotate(err).Reason("could not get absolute path for: %(python)s").
- D("python", cfg.Python).
- Err()
+ return errors.Annotate(err, "could not get absolute path for: %s", cfg.Python).Err()
}
return nil
}
diff --git a/vpython/venv/iterator.go b/vpython/venv/iterator.go
index b1c7ba2..5b97bff 100644
--- a/vpython/venv/iterator.go
+++ b/vpython/venv/iterator.go
@@ -75,9 +75,7 @@
// Get a listing of all VirtualEnv within the base directory.
dir, err := os.Open(dirPath)
if err != nil {
- return errors.Annotate(err).Reason("failed to open base directory: %(dir)s").
- D("dir", dirPath).
- Err()
+ return errors.Annotate(err, "failed to open base directory: %s", dirPath).Err()
}
defer dir.Close()
@@ -98,9 +96,7 @@
done = true
default:
- return errors.Annotate(err).Reason("could not read directory contents: %(dir)s").
- D("dir", dirPath).
- Err()
+ return errors.Annotate(err, "could not read directory contents: %s", dirPath).Err()
}
if err := cb(fileInfos); err != nil {
diff --git a/vpython/venv/prune.go b/vpython/venv/prune.go
index f000045..5a786ec 100644
--- a/vpython/venv/prune.go
+++ b/vpython/venv/prune.go
@@ -84,10 +84,8 @@
logging.WithError(err).Debugf(c, "Environment [%s] is in use.", e.Name)
default:
- err = errors.Annotate(err).Reason("failed to prune file: %(name)s").
- D("name", e.Name).
- D("dir", e.Config.BaseDir).
- Err()
+ err = errors.Annotate(err, "failed to prune file: %s", e.Name).
+ InternalReason("dir(%q)", e.Config.BaseDir).Err()
allErrs = append(allErrs, err)
}
return nil
diff --git a/vpython/venv/system_posix.go b/vpython/venv/system_posix.go
index de3e8e2..3d78d44 100644
--- a/vpython/venv/system_posix.go
+++ b/vpython/venv/system_posix.go
@@ -28,11 +28,11 @@
func checkProcessRunning(pid int) error {
proc, err := os.FindProcess(pid)
if err != nil {
- return errors.Annotate(err).Reason("failed to find process").Err()
+ return errors.Annotate(err, "failed to find process").Err()
}
if err := proc.Signal(os.Signal(syscall.Signal(0))); err != nil {
- return errors.Annotate(err).Reason("failed to signal process").Err()
+ return errors.Annotate(err, "failed to signal process").Err()
}
return nil
}
diff --git a/vpython/venv/system_windows.go b/vpython/venv/system_windows.go
index 81e1767..aa128c7 100644
--- a/vpython/venv/system_windows.go
+++ b/vpython/venv/system_windows.go
@@ -26,11 +26,11 @@
func checkProcessRunning(pid int) error {
proc, err := os.FindProcess(pid)
if err != nil {
- return errors.Annotate(err).Reason("failed to find process").Err()
+ return errors.Annotate(err, "failed to find process").Err()
}
if err := proc.Signal(os.Signal(syscall.Signal(0))); err != nil {
- return errors.Annotate(err).Reason("failed to signal process").Err()
+ return errors.Annotate(err, "failed to signal process").Err()
}
return nil
}
diff --git a/vpython/venv/util.go b/vpython/venv/util.go
index 4ac827c..3e88b45 100644
--- a/vpython/venv/util.go
+++ b/vpython/venv/util.go
@@ -15,16 +15,16 @@
func writeTextProto(path string, msg proto.Message) error {
fd, err := os.Create(path)
if err != nil {
- return errors.Annotate(err).Reason("failed to create output file").Err()
+ return errors.Annotate(err, "failed to create output file").Err()
}
if err := proto.MarshalText(fd, msg); err != nil {
_ = fd.Close()
- return errors.Annotate(err).Reason("failed to output text protobuf").Err()
+ return errors.Annotate(err, "failed to output text protobuf").Err()
}
if err := fd.Close(); err != nil {
- return errors.Annotate(err).Reason("failed to Close temporary file").Err()
+ return errors.Annotate(err, "failed to Close temporary file").Err()
}
return nil
diff --git a/vpython/venv/venv.go b/vpython/venv/venv.go
index 0ff764e..646c1ea 100644
--- a/vpython/venv/venv.go
+++ b/vpython/venv/venv.go
@@ -55,7 +55,7 @@
func withTempDir(l logging.Logger, prefix string, fn func(string) error) error {
tdir, err := ioutil.TempDir("", prefix)
if err != nil {
- return errors.Annotate(err).Reason("failed to create temporary directory").Err()
+ return errors.Annotate(err, "failed to create temporary directory").Err()
}
defer func() {
if err := filesystem.RemoveAll(tdir); err != nil {
@@ -76,9 +76,8 @@
// could have overridden it or exported their own, let's make sure.
func EnvRootFromStampPath(path string) (string, error) {
if err := filesystem.AbsPath(&path); err != nil {
- return "", errors.Annotate(err).
- Reason("failed to get absolute path for specification file path: %(path)s").
- Err()
+ return "", errors.Annotate(err,
+ "failed to get absolute path for specification file path: %(path)s", path).Err()
}
return filepath.Dir(filepath.Dir(path)), nil
}
@@ -113,10 +112,10 @@
// full environment initialization.
emptyEnv, err := cfg.WithoutWheels().makeEnv(c, nil)
if err != nil {
- return errors.Annotate(err).Reason("failed to initialize empty probe environment").Err()
+ return errors.Annotate(err, "failed to initialize empty probe environment").Err()
}
if err := emptyEnv.ensure(c, blocking); err != nil {
- return errors.Annotate(err).Reason("failed to create empty probe environment").Err()
+ return errors.Annotate(err, "failed to create empty probe environment").Err()
}
usedEnvs.Add(emptyEnv.Name)
@@ -228,13 +227,13 @@
// No complete flag. Create a new VirtualEnv here.
if err := e.createLocked(c); err != nil {
- return errors.Annotate(err).Reason("failed to create new VirtualEnv").Err()
+ return errors.Annotate(err, "failed to create new VirtualEnv").Err()
}
// Mark that this environment is complete. This MUST succeed so other
// instances know that this environment is complete.
if err := e.touchCompleteFlagLocked(); err != nil {
- return errors.Annotate(err).Reason("failed to create complete flag").Err()
+ return errors.Annotate(err, "failed to create complete flag").Err()
}
logging.Debugf(c, "Successfully created new virtual environment [%s]!", e.Name)
@@ -256,7 +255,7 @@
"path": e.EnvironmentStampPath,
}.Debugf(c, "Lock is held, and environment is not complete.")
if !blocking {
- return errors.Annotate(err).Reason("VirtualEnv lock is currently held (non-blocking)").Err()
+ return errors.Annotate(err, "VirtualEnv lock is currently held (non-blocking)").Err()
}
// Some other process holds the lock. Sleep a little and retry.
@@ -265,7 +264,7 @@
}
default:
- return errors.Annotate(err).Reason("failed to create VirtualEnv").Err()
+ return errors.Annotate(err, "failed to create VirtualEnv").Err()
}
}
}
@@ -330,7 +329,7 @@
"path": e.EnvironmentStampPath,
}.Debugf(c, "Could not obtain shared usage lock.")
if !blocking {
- return errors.Annotate(err).Reason("VirtualEnv lock is currently held (non-blocking)").Err()
+ return errors.Annotate(err, "VirtualEnv lock is currently held (non-blocking)").Err()
}
// Some other process holds the lock. Sleep a little and retry.
@@ -339,7 +338,7 @@
}
default:
- return errors.Annotate(err).Reason("failed to use VirtualEnv").Err()
+ return errors.Annotate(err, "failed to use VirtualEnv").Err()
}
}
}
@@ -384,19 +383,16 @@
content, err := ioutil.ReadFile(e.EnvironmentStampPath)
if err != nil {
- return errors.Annotate(err).Reason("failed to load file from: %(path)s").
- D("path", e.EnvironmentStampPath).
- Err()
+ return errors.Annotate(err, "failed to load file from: %s", e.EnvironmentStampPath).Err()
}
var environment vpython.Environment
if err := proto.UnmarshalText(string(content), &environment); err != nil {
- return errors.Annotate(err).Reason("failed to unmarshal vpython.Env stamp from: %(path)s").
- D("path", e.EnvironmentStampPath).
- Err()
+ return errors.Annotate(err, "failed to unmarshal vpython.Env stamp from: %s",
+ e.EnvironmentStampPath).Err()
}
if err := spec.NormalizeEnvironment(&environment); err != nil {
- return errors.Annotate(err).Reason("failed to normalize stamp environment").Err()
+ return errors.Annotate(err, "failed to normalize stamp environment").Err()
}
// If we are configured with an environment, validate that it matches the
@@ -424,7 +420,7 @@
case filesystem.IsNotExist(err):
return ErrNotComplete
case err != nil:
- return errors.Annotate(err).Reason("failed to check for completion flag").Err()
+ return errors.Annotate(err, "failed to check for completion flag").Err()
default:
return nil
}
@@ -441,7 +437,7 @@
// Make sure our environment's base directory exists.
if err := filesystem.MakeDirs(e.Root); err != nil {
- return errors.Annotate(err).Reason("failed to create environment root").Err()
+ return errors.Annotate(err, "failed to create environment root").Err()
}
logging.Infof(c, "Using virtual environment root: %s", e.Root)
@@ -460,23 +456,23 @@
err := withTempDir(logging.Get(c), "vpython_bootstrap", func(bootstrapDir string) error {
pkgDir := filepath.Join(bootstrapDir, "packages")
if err := filesystem.MakeDirs(pkgDir); err != nil {
- return errors.Annotate(err).Reason("could not create bootstrap packages directory").Err()
+ return errors.Annotate(err, "could not create bootstrap packages directory").Err()
}
if err := e.downloadPackages(c, pkgDir, packages); err != nil {
- return errors.Annotate(err).Reason("failed to download packages").Err()
+ return errors.Annotate(err, "failed to download packages").Err()
}
// Installing base VirtualEnv.
if err := e.installVirtualEnv(c, pkgDir); err != nil {
- return errors.Annotate(err).Reason("failed to install VirtualEnv").Err()
+ return errors.Annotate(err, "failed to install VirtualEnv").Err()
}
// Load PEP425 tags, if we don't already have them.
if e.Environment.Pep425Tag == nil {
pep425Tags, err := e.getPEP425Tags(c)
if err != nil {
- return errors.Annotate(err).Reason("failed to get PEP425 tags").Err()
+ return errors.Annotate(err, "failed to get PEP425 tags").Err()
}
e.Environment.Pep425Tag = pep425Tags
}
@@ -485,7 +481,7 @@
if len(e.Environment.Spec.Wheel) > 0 {
// Install wheels into our VirtualEnv.
if err := e.installWheels(c, bootstrapDir, pkgDir); err != nil {
- return errors.Annotate(err).Reason("failed to install wheels").Err()
+ return errors.Annotate(err, "failed to install wheels").Err()
}
}
return nil
@@ -496,15 +492,14 @@
// Write our specification file.
if err := e.WriteEnvironmentStamp(); err != nil {
- return errors.Annotate(err).Reason("failed to write environment stamp file to: %(path)s").
- D("path", e.EnvironmentStampPath).
- Err()
+ return errors.Annotate(err, "failed to write environment stamp file to: %s",
+ e.EnvironmentStampPath).Err()
}
logging.Debugf(c, "Wrote environment stamp file to: %s", e.EnvironmentStampPath)
// Finalize our VirtualEnv for bootstrap execution.
if err := e.finalize(c); err != nil {
- return errors.Annotate(err).Reason("failed to prepare VirtualEnv").Err()
+ return errors.Annotate(err, "failed to prepare VirtualEnv").Err()
}
return nil
@@ -514,7 +509,7 @@
// Create a wheel sub-directory underneath of root.
logging.Debugf(c, "Loading %d package(s) into: %s", len(packages), dst)
if err := e.Config.Loader.Ensure(c, dst, packages); err != nil {
- return errors.Annotate(err).Reason("failed to download packages").Err()
+ return errors.Annotate(err, "failed to download packages").Err()
}
return nil
}
@@ -523,15 +518,14 @@
// Create our VirtualEnv package staging sub-directory underneath of root.
bsDir := filepath.Join(e.Root, ".virtualenv")
if err := filesystem.MakeDirs(bsDir); err != nil {
- return errors.Annotate(err).Reason("failed to create VirtualEnv bootstrap directory").
- D("path", bsDir).
- Err()
+ return errors.Annotate(err, "failed to create VirtualEnv bootstrap directory").
+ InternalReason("path(%s)", bsDir).Err()
}
// Identify the virtualenv directory: will have "virtualenv-" prefix.
matches, err := filepath.Glob(filepath.Join(pkgDir, "virtualenv-*"))
if err != nil {
- return errors.Annotate(err).Reason("failed to glob for 'virtualenv-' directory").Err()
+ return errors.Annotate(err, "failed to glob for 'virtualenv-' directory").Err()
}
if len(matches) == 0 {
return errors.Reason("no 'virtualenv-' directory provided by package").Err()
@@ -546,7 +540,7 @@
cmd.Dir = venvDir
attachOutputForLogging(c, logging.Debug, cmd)
if err := cmd.Run(); err != nil {
- return errors.Annotate(err).Reason("failed to create VirtualEnv").Err()
+ return errors.Annotate(err, "failed to create VirtualEnv").Err()
}
logging.Debugf(c, "Making VirtualEnv relocatable at: %s", e.Root)
@@ -557,7 +551,7 @@
cmd.Dir = venvDir
attachOutputForLogging(c, logging.Debug, cmd)
if err := cmd.Run(); err != nil {
- return errors.Annotate(err).Reason("failed to create VirtualEnv").Err()
+ return errors.Annotate(err, "failed to create VirtualEnv").Err()
}
return nil
@@ -584,23 +578,19 @@
attachOutputForLogging(c, logging.Debug, cmd)
if err := cmd.Run(); err != nil {
- return nil, errors.Annotate(err).Reason("failed to get PEP425 tags").Err()
+ return nil, errors.Annotate(err, "failed to get PEP425 tags").Err()
}
var tagEntries []pep425TagEntry
if err := json.Unmarshal(stdout.Bytes(), &tagEntries); err != nil {
- return nil, errors.Annotate(err).Reason("failed to unmarshal PEP425 tag output: %(output)s").
- D("output", stdout.String()).
- Err()
+ return nil, errors.Annotate(err, "failed to unmarshal PEP425 tag output: %s", stdout).Err()
}
tags := make([]*vpython.PEP425Tag, len(tagEntries))
for i, te := range tagEntries {
if len(te) != 3 {
- return nil, errors.Reason("invalid PEP425 tag entry: %(entry)v").
- D("entry", te).
- D("index", i).
- Err()
+ return nil, errors.Reason("invalid PEP425 tag entry: %v", te).
+ InternalReason("index(%d)", i).Err()
}
tags[i] = &vpython.PEP425Tag{
@@ -626,14 +616,14 @@
// Identify all downloaded wheels and parse them.
wheels, err := wheel.ScanDir(pkgDir)
if err != nil {
- return errors.Annotate(err).Reason("failed to load wheels").Err()
+ return errors.Annotate(err, "failed to load wheels").Err()
}
// Build a "wheel" requirements file.
reqPath := filepath.Join(bootstrapDir, "requirements.txt")
logging.Debugf(c, "Rendering requirements file to: %s", reqPath)
if err := wheel.WriteRequirementsFile(reqPath, wheels); err != nil {
- return errors.Annotate(err).Reason("failed to render requirements file").Err()
+ return errors.Annotate(err, "failed to render requirements file").Err()
}
cmd := e.Interpreter().IsolatedCommand(c,
@@ -646,7 +636,7 @@
"--requirement", reqPath)
attachOutputForLogging(c, logging.Debug, cmd)
if err := cmd.Run(); err != nil {
- return errors.Annotate(err).Reason("failed to install wheels").Err()
+ return errors.Annotate(err, "failed to install wheels").Err()
}
return nil
}
@@ -666,7 +656,7 @@
}
})
if err != nil {
- return errors.Annotate(err).Reason("failed to mark environment read-only").Err()
+ return errors.Annotate(err, "failed to mark environment read-only").Err()
}
}
return nil
@@ -674,7 +664,7 @@
func (e *Env) touchCompleteFlagLocked() error {
if err := filesystem.Touch(e.completeFlagPath, time.Time{}, 0644); err != nil {
- return errors.Annotate(err).Err()
+ return errors.Annotate(err, "").Err()
}
return nil
}
@@ -695,7 +685,7 @@
// Delete our environment directory.
if err := filesystem.RemoveAll(e.Root); err != nil {
- return errors.Annotate(err).Reason("failed to delete environment root").Err()
+ return errors.Annotate(err, "failed to delete environment root").Err()
}
// Attempt to delete our lock. On POSIX systems, this will successfully
@@ -715,13 +705,13 @@
logging.Debugf(c, "(Delete) Released exclusive lock for: %s", e.Name)
if err != nil {
- return errors.Annotate(err).Reason("failed to delete environment").Err()
+ return errors.Annotate(err, "failed to delete environment").Err()
}
// Try and remove the lock now that we don't hold it.
if !removedLock {
if err := os.Remove(e.lockPath); err != nil {
- return errors.Annotate(err).Reason("failed to remove lock").Err()
+ return errors.Annotate(err, "failed to remove lock").Err()
}
}
return nil
@@ -745,9 +735,8 @@
return time.Time{}, nil
default:
- return time.Time{}, errors.Annotate(err).Reason("failed to stat completion flag: %(path)s").
- D("path", e.completeFlagPath).
- Err()
+ return time.Time{}, errors.Annotate(err, "failed to stat completion flag: %s",
+ e.completeFlagPath).Err()
}
}
@@ -773,7 +762,7 @@
func mustReleaseLock(c context.Context, lock fslock.Handle, fn func() error) error {
defer func() {
if err := lock.Unlock(); err != nil {
- errors.Log(c, errors.Annotate(err).Reason("failed to release lock").Err())
+ errors.Log(c, errors.Annotate(err, "failed to release lock").Err())
panic(err)
}
}()
diff --git a/vpython/venv/venv_resources_test.go b/vpython/venv/venv_resources_test.go
index 96e7894..51d73be 100644
--- a/vpython/venv/venv_resources_test.go
+++ b/vpython/venv/venv_resources_test.go
@@ -91,12 +91,12 @@
func loadTestEnvironment(ctx context.Context, t *testing.T) (*testingLoader, error) {
wd, err := os.Getwd()
if err != nil {
- return nil, errors.Annotate(err).Reason("failed to get working directory").Err()
+ return nil, errors.Annotate(err, "failed to get working directory").Err()
}
cacheDir := filepath.Join(wd, ".venv_test_cache")
if err := filesystem.MakeDirs(cacheDir); err != nil {
- return nil, errors.Annotate(err).Reason("failed to create cache dir").Err()
+ return nil, errors.Annotate(err, "failed to create cache dir").Err()
}
tl := testingLoader{
@@ -158,9 +158,7 @@
return copyFileIntoDir(tl.pantsWheelPath, root)
default:
- return errors.Reason("don't know how to install %(package)q").
- D("package", name).
- Err()
+ return errors.Reason("don't know how to install %q", name).Err()
}
}
@@ -168,9 +166,7 @@
ctx := context.Background()
w, err := wheel.ParseName(name)
if err != nil {
- return "", errors.Annotate(err).Reason("failed to parse wheel name %(name)q").
- D("name", name).
- Err()
+ return "", errors.Annotate(err, "failed to parse wheel name %q", name).Err()
}
outWheelPath := filepath.Join(outDir, w.String())
@@ -184,9 +180,7 @@
break
default:
- return "", errors.Annotate(err).Reason("failed to stat wheel path [%(path)s]").
- D("path", outWheelPath).
- Err()
+ return "", errors.Annotate(err, "failed to stat wheel path [%s]", outWheelPath).Err()
}
srcDir := filepath.Join(testDataDir, w.Distribution+".src")
@@ -234,22 +228,22 @@
"--dist-dir", distDir)
cmd.Dir = srcDir
if err := cmd.Run(); err != nil {
- return errors.Annotate(err).Reason("failed to build wheel").Err()
+ return errors.Annotate(err, "failed to build wheel").Err()
}
return nil
})
if err != nil {
- return errors.Annotate(err).Reason("failed to build wheel").Err()
+ return errors.Annotate(err, "failed to build wheel").Err()
}
// Assert that the expected wheel file was generated, and copy it into
// outDir.
wheelPath := filepath.Join(distDir, w.String())
if _, err := os.Stat(wheelPath); err != nil {
- return errors.Annotate(err).Reason("failed to generate wheel").Err()
+ return errors.Annotate(err, "failed to generate wheel").Err()
}
if err := copyFileIntoDir(wheelPath, outDir); err != nil {
- return errors.Annotate(err).Reason("failed to install wheel").Err()
+ return errors.Annotate(err, "failed to install wheel").Err()
}
return nil
@@ -298,9 +292,7 @@
t.Logf("Failed to load from URL %q: %s", url, err)
}
- return errors.Reason("failed to acquire remote file %(name)q").
- D("name", rf.name).
- Err()
+ return errors.Reason("failed to acquire remote file %q", rf.name).Err()
}
return nil
@@ -313,13 +305,13 @@
func validateHash(t *testing.T, path, hash string, deleteIfInvalid bool) error {
fd, err := os.Open(path)
if err != nil {
- return errors.Annotate(err).Reason("failed to open file").Err()
+ return errors.Annotate(err, "failed to open file").Err()
}
defer fd.Close()
h := sha256.New()
if _, err := io.Copy(h, fd); err != nil {
- return errors.Annotate(err).Reason("failed to hash file").Err()
+ return errors.Annotate(err, "failed to hash file").Err()
}
if err := hashesEqual(h, hash); err != nil {
@@ -338,10 +330,7 @@
func hashesEqual(h hash.Hash, expected string) error {
if v := hex.EncodeToString(h.Sum(nil)); v != expected {
- return errors.Reason("hash %(actual)q doesn't match expected %(expected)q").
- D("actual", v).
- D("expected", expected).
- Err()
+ return errors.Reason("hash %q doesn't match expected %q", v, expected).Err()
}
return nil
}
@@ -358,19 +347,16 @@
client, err := cipd.NewClient(opts)
if err != nil {
- return errors.Annotate(err).Reason("failed to create CIPD client").Err()
+ return errors.Annotate(err, "failed to create CIPD client").Err()
}
pin, err := client.ResolveVersion(ctx, pkg, version)
if err != nil {
- return errors.Annotate(err).Reason("failed to resolve CIPD version for %(pkg)s @%(version)s").
- D("pkg", pkg).
- D("version", version).
- Err()
+ return errors.Annotate(err, "failed to resolve CIPD version for %s @%s", pkg, version).Err()
}
if err := client.FetchAndDeployInstance(ctx, "", pin); err != nil {
- return errors.Annotate(err).Reason("failed to fetch/deploy CIPD package").Err()
+ return errors.Annotate(err, "failed to fetch/deploy CIPD package").Err()
}
path := filepath.Join(opts.Root, name)
@@ -380,7 +366,7 @@
}
if err := copyFile(path, cachePath, nil); err != nil {
- return errors.Annotate(err).Reason("failed to install CIPD package file").Err()
+ return errors.Annotate(err, "failed to install CIPD package file").Err()
}
return nil
@@ -400,14 +386,14 @@
}
defer func() {
if closeErr := fd.Close(); closeErr != nil && err == nil {
- err = errors.Annotate(closeErr).Reason("failed to close file").Err()
+ err = errors.Annotate(closeErr, "failed to close file").Err()
}
}()
h := sha256.New()
tr := io.TeeReader(resp.Body, h)
if _, err := io.Copy(fd, tr); err != nil {
- return errors.Annotate(err).Reason("failed to download").Err()
+ return errors.Annotate(err, "failed to download").Err()
}
if err = hashesEqual(h, hash); err != nil {
@@ -419,7 +405,7 @@
func unzip(src, dst string) error {
fd, err := zip.OpenReader(src)
if err != nil {
- return errors.Annotate(err).Reason("failed to open ZIP reader").Err()
+ return errors.Annotate(err, "failed to open ZIP reader").Err()
}
defer fd.Close()
@@ -430,7 +416,7 @@
// Unzip this entry.
if fi.IsDir() {
if err := os.MkdirAll(path, 0755); err != nil {
- return errors.Annotate(err).Reason("failed to mkdir").Err()
+ return errors.Annotate(err, "failed to mkdir").Err()
}
} else {
if err := copyFileOpener(f.Open, path, fi); err != nil {
@@ -453,26 +439,26 @@
func copyFileOpener(opener func() (io.ReadCloser, error), dst string, fi os.FileInfo) (err error) {
sfd, err := opener()
if err != nil {
- return errors.Annotate(err).Reason("failed to open source").Err()
+ return errors.Annotate(err, "failed to open source").Err()
}
defer sfd.Close()
dfd, err := os.Create(dst)
if err != nil {
- return errors.Annotate(err).Reason("failed to create destination").Err()
+ return errors.Annotate(err, "failed to create destination").Err()
}
defer func() {
if closeErr := dfd.Close(); closeErr != nil && err == nil {
- err = errors.Annotate(closeErr).Reason("failed to close destination").Err()
+ err = errors.Annotate(closeErr, "failed to close destination").Err()
}
}()
if _, err := io.Copy(dfd, sfd); err != nil {
- return errors.Annotate(err).Reason("failed to copy file").Err()
+ return errors.Annotate(err, "failed to copy file").Err()
}
if fi != nil {
if err := os.Chmod(dst, fi.Mode()); err != nil {
- return errors.Annotate(err).Reason("failed to chmod").Err()
+ return errors.Annotate(err, "failed to chmod").Err()
}
}
return nil
diff --git a/vpython/venv/venv_test.go b/vpython/venv/venv_test.go
index 8d2fe2a..947b53e 100644
--- a/vpython/venv/venv_test.go
+++ b/vpython/venv/venv_test.go
@@ -267,10 +267,10 @@
func loadJSON(path string, dst interface{}) error {
content, err := ioutil.ReadFile(path)
if err != nil {
- return errors.Annotate(err).Reason("failed to open file").Err()
+ return errors.Annotate(err, "failed to open file").Err()
}
if err := json.Unmarshal(content, dst); err != nil {
- return errors.Annotate(err).Reason("failed to unmarshal JSON").Err()
+ return errors.Annotate(err, "failed to unmarshal JSON").Err()
}
return nil
}
diff --git a/vpython/wheel/wheel.go b/vpython/wheel/wheel.go
index 042c9f8..9ab6b2d 100644
--- a/vpython/wheel/wheel.go
+++ b/vpython/wheel/wheel.go
@@ -48,7 +48,7 @@
func ParseName(v string) (wn Name, err error) {
base := strings.TrimSuffix(v, ".whl")
if len(base) == len(v) {
- err = errors.Reason("missing .whl suffix").Err()
+ err = errors.New("missing .whl suffix")
return
}
@@ -68,9 +68,7 @@
wn.PlatformTag = parts[4+skip]
default:
- err = errors.Reason("unknown number of segments (%(segments)d)").
- D("segments", len(parts)).
- Err()
+ err = errors.Reason("unknown number of segments (%d)", len(parts)).Err()
return
}
return
@@ -82,19 +80,15 @@
globPattern := filepath.Join(dir, "*.whl")
matches, err := filepath.Glob(globPattern)
if err != nil {
- return nil, errors.Annotate(err).Reason("failed to list wheel directory: %(dir)s").
- D("dir", dir).
- D("pattern", globPattern).
- Err()
+ return nil, errors.Annotate(err, "failed to list wheel directory: %s", dir).
+ InternalReason("pattern(%s)", globPattern).Err()
}
names := make([]Name, 0, len(matches))
for _, match := range matches {
switch st, err := os.Stat(match); {
case err != nil:
- return nil, errors.Annotate(err).Reason("failed to stat wheel: %(path)s").
- D("path", match).
- Err()
+ return nil, errors.Annotate(err, "failed to stat wheel: %s", match).Err()
case st.IsDir():
// Ignore directories.
@@ -105,10 +99,8 @@
name := filepath.Base(match)
wheelName, err := ParseName(name)
if err != nil {
- return nil, errors.Annotate(err).Reason("failed to parse wheel from: %(name)s").
- D("name", name).
- D("dir", dir).
- Err()
+ return nil, errors.Annotate(err, "failed to parse wheel from: %s", name).
+ InternalReason("dir(%s)", dir).Err()
}
names = append(names, wheelName)
}
@@ -124,12 +116,12 @@
func WriteRequirementsFile(path string, wheels []Name) (err error) {
fd, err := os.Create(path)
if err != nil {
- return errors.Annotate(err).Reason("failed to create requirements file").Err()
+ return errors.Annotate(err, "failed to create requirements file").Err()
}
defer func() {
closeErr := fd.Close()
if closeErr != nil && err == nil {
- err = errors.Annotate(closeErr).Reason("failed to Close").Err()
+ err = errors.Annotate(closeErr, "failed to Close").Err()
}
}()
@@ -148,7 +140,7 @@
seen[archetype] = struct{}{}
if _, err := fmt.Fprintf(fd, "%s==%s\n", archetype.Distribution, archetype.Version); err != nil {
- return errors.Annotate(err).Reason("failed to write to requirements file").Err()
+ return errors.Annotate(err, "failed to write to requirements file").Err()
}
}
