[errors] Greatly simplify common/errors package.

deploytool/cmd/luci_deploy/appengine.go

 // Copyright 2016 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package main
 
 import (
         "io/ioutil"
         "path/filepath"
         "strings"
@@ skipping 175 matching lines @@
         case *deploy.AppEngineModule_StaticModule_:
                 // A static module presents itself as an empty Python AppEngine module. This
                 // doesn't actually need any Python code to support it.
                 appYAML.Runtime = "python27"
                 appYAML.APIVersion = "1"
                 threadSafe := true
                 appYAML.ThreadSafe = &threadSafe
                 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
         switch p := aem.GetParams().(type) {
         case *deploy.AppEngineModule_Classic:
                 var icPrefix string
                 switch sc := p.Classic.GetScaling().(type) {
                 case nil:
                         // (Automatic, default).
                         icPrefix = "F"
@@ skipping 18 matching lines @@
                         icPrefix = "B"
 
                 case *deploy.AppEngineModule_ClassicParams_ManualScaling_:
                         ms := sc.ManualScaling
                         appYAML.ManualScaling = &gaeAppManualScalingParams{
                                 Instances: int(ms.Instances),
                         }
                         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)
 
         case *deploy.AppEngineModule_ManagedVm:
                 if scopes := p.ManagedVm.Scopes; len(scopes) > 0 {
                         appYAML.BetaSettings = &gaeAppYAMLBetaSettings{
                                 ServiceAccountScopes: strings.Join(scopes, ","),
                         }
                 }
         }
@@ skipping 22 matching lines @@
                                 entry.StaticDir = staticMap[t.StaticBuildDir]
 
                         case *deploy.AppEngineModule_Handler_StaticFiles_:
                                 sf := t.StaticFiles
 
                                 relDir := staticMap[sf.GetBuild()]
                                 entry.Upload = filepath.Join(relDir, sf.Upload)
                                 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 {
                                 return nil, errors.Reason("stub module cannot have entry script").Err()
                         }
 
                         appYAML.Handlers[i] = &entry
                 }
         }
 
@@ skipping 41 matching lines @@
 
         for _, m := range cp.appEngineModules {
                 for _, url := range m.resources.Dispatch {
                         dispatchYAML.Dispatch = append(dispatchYAML.Dispatch, &gaeDispatchYAMLEntry{
                                 Module: m.ModuleName,
                                 URL:    url,
                         })
                 }
         }
         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
 }
 
 func gaeBuildQueueYAML(cp *layoutDeploymentCloudProject) (*gaeQueueYAML, error) {
         var queueYAML gaeQueueYAML
 
         for _, m := range cp.appEngineModules {
                 for _, queue := range m.resources.TaskQueue {
                         entry := gaeQueueYAMLEntry{
                                 Name: queue.Name,
                         }
                         switch t := queue.GetType().(type) {
                         case *deploy.AppEngineResources_TaskQueue_Push_:
                                 push := t.Push
 
                                 entry.Target = m.ModuleName
                                 entry.Mode = "push"
                                 entry.Rate = push.Rate
                                 entry.BucketSize = int(push.BucketSize)
                                 entry.MaxConcurrentRequests = int(push.MaxConcurrentRequests)
                                 entry.RetryParameters = &gaeQueueYAMLEntryRetryParameters{
                                         TaskAgeLimit:      push.RetryTaskAgeLimit,
                                         MinBackoffSeconds: int(push.RetryMinBackoffSeconds),
                                         MaxBackoffSeconds: int(push.RetryMaxBackoffSeconds),
                                         MaxDoublings:      int(push.RetryMaxDoublings),
                                 }
 
                         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)
                 }
         }
         return &queueYAML, nil
 }
 
 // loadIndexYAMLResource loads an AppEngine "index.yaml" file from the specified
 // filesystem path and translates it into AppEngineResources Index entries.
 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
         if len(indexYAML.Indexes) > 0 {
                 res.Index = make([]*deploy.AppEngineResources_Index, len(indexYAML.Indexes))
                 for i, idx := range indexYAML.Indexes {
                         entry := deploy.AppEngineResources_Index{
                                 Kind:     idx.Kind,
                                 Ancestor: yesOrBoolToBool(idx.Ancestor),
                                 Property: make([]*deploy.AppEngineResources_Index_Property, len(idx.Properties)),
                         }
                         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{
                                         Name:      idxProp.Name,
                                         Direction: dir,
                                 }
                         }
 
                         res.Index[i] = &entry
                 }
@@ skipping 13 matching lines @@
 func yesOrBoolToBool(v interface{}) bool {
         switch t := v.(type) {
         case string:
                 return (t == "yes")
         case bool:
                 return t
         default:
                 return false
         }
 }