Differentiate between server error messages and client error messages in kubectl

pkg/api/errors/errors.go

@@ -262,6 +262,18 @@ func IsServerTimeout(err error) bool {
 	return reasonForError(err) == api.StatusReasonServerTimeout
 }
 
+// IsStatusError determines if err is an API Status error received from the master.
+func IsStatusError(err error) bool {
+	_, ok := err.(*StatusError)
+	return ok
+}
+
+// IsUnexpectedObjectError determines if err is due to an unexpected object from the master.
+func IsUnexpectedObjectError(err error) bool {
+	_, ok := err.(*UnexpectedObjectError)
+	return ok
+}
+
 func reasonForError(err error) api.StatusReason {
 	switch t := err.(type) {
 	case *StatusError:

pkg/client/request.go

@@ -62,6 +62,12 @@ func (u *UnexpectedStatusError) Error() string {
 	return fmt.Sprintf("request [%+v] failed (%d) %s: %s", u.Request, u.Response.StatusCode, u.Response.Status, u.Body)
 }
 
+// IsUnexpectedStatusError determines if err is due to an unexpected status from the server.
+func IsUnexpectedStatusError(err error) bool {
+	_, ok := err.(*UnexpectedStatusError)
+	return ok
+}
+
 // RequestConstructionError is returned when there's an error assembling a request.
 type RequestConstructionError struct {
 	Err error
@@ -576,7 +582,8 @@ func (r *Request) transformResponse(body []byte, resp *http.Response, req *http.
 		// no-op, we've been upgraded
 	case resp.StatusCode < http.StatusOK || resp.StatusCode > http.StatusPartialContent:
 		if !isStatusResponse {
-			var err error = &UnexpectedStatusError{
+			var err error
+			err = &UnexpectedStatusError{
 				Request:  req,
 				Response: resp,
 				Body:     string(body),

pkg/kubectl/cmd/clusterinfo.go

@@ -22,6 +22,7 @@ import (
 	"strings"
 
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/kubectl/cmd/util"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/kubectl/resource"
 
 	"github.com/spf13/cobra"
@@ -41,12 +42,12 @@ func (f *Factory) NewCmdClusterInfo(out io.Writer) *cobra.Command {
 
 func RunClusterInfo(factory *Factory, out io.Writer, cmd *cobra.Command) {
 	client, err := factory.ClientConfig(cmd)
-	checkErr(err)
+	util.CheckErr(err)
 	fmt.Fprintf(out, "Kubernetes master is running at %v\n", client.Host)
 
 	mapper, typer := factory.Object(cmd)
 	cmdNamespace, err := factory.DefaultNamespace(cmd)
-	checkErr(err)
+	util.CheckErr(err)
 
 	// TODO: use generalized labels once they are implemented (#341)
 	b := resource.NewBuilder(mapper, typer, factory.ClientMapperForCommand(cmd)).

pkg/kubectl/cmd/cmd.go

@@ -97,7 +97,7 @@ func NewFactory(optionalClientConfig clientcmd.ClientConfig) *Factory {
 
 		Object: func(cmd *cobra.Command) (meta.RESTMapper, runtime.ObjectTyper) {
 			cfg, err := clientConfig.ClientConfig()
-			checkErr(err)
+			cmdutil.CheckErr(err)
 			cmdApiVersion := cfg.Version
 
 			return kubectl.OutputVersionMapper{mapper, cmdApiVersion}, api.Scheme
@@ -253,7 +253,7 @@ func (f *Factory) PrinterForMapping(cmd *cobra.Command, mapping *meta.RESTMappin
 	}
 	if ok {
 		clientConfig, err := f.ClientConfig(cmd)
-		checkErr(err)
+		cmdutil.CheckErr(err)
 		defaultVersion := clientConfig.Version
 
 		version := cmdutil.OutputVersion(cmd, defaultVersion)
@@ -329,12 +329,6 @@ func DefaultClientConfig(flags *pflag.FlagSet) clientcmd.ClientConfig {
 	return clientConfig
 }
 
-func checkErr(err error) {
-	if err != nil {
-		glog.FatalDepth(1, err.Error())
-	}
-}
-
 func usageError(cmd *cobra.Command, format string, args ...interface{}) {
 	glog.Errorf(format, args...)
 	glog.Errorf("See '%s -h' for help.", cmd.CommandPath())

pkg/kubectl/cmd/create.go

@@ -22,6 +22,7 @@ import (
 
 	"github.com/spf13/cobra"
 
+	cmdutil "github.com/GoogleCloudPlatform/kubernetes/pkg/kubectl/cmd/util"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/kubectl/resource"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
 )
@@ -48,10 +49,10 @@ func (f *Factory) NewCmdCreate(out io.Writer) *cobra.Command {
 		Example: create_example,
 		Run: func(cmd *cobra.Command, args []string) {
 			schema, err := f.Validator(cmd)
-			checkErr(err)
+			cmdutil.CheckErr(err)
 
 			cmdNamespace, err := f.DefaultNamespace(cmd)
-			checkErr(err)
+			cmdutil.CheckErr(err)
 
 			mapper, typer := f.Object(cmd)
 			r := resource.NewBuilder(mapper, typer, f.ClientMapperForCommand(cmd)).
@@ -60,7 +61,7 @@ func (f *Factory) NewCmdCreate(out io.Writer) *cobra.Command {
 				FilenameParam(flags.Filenames...).
 				Flatten().
 				Do()
-			checkErr(r.Err())
+			cmdutil.CheckErr(r.Err())
 
 			count := 0
 			err = r.Visit(func(info *resource.Info) error {
@@ -80,9 +81,9 @@ func (f *Factory) NewCmdCreate(out io.Writer) *cobra.Command {
 				fmt.Fprintf(out, "%s\n", info.Name)
 				return nil
 			})
-			checkErr(err)
+			cmdutil.CheckErr(err)
 			if count == 0 {
-				checkErr(fmt.Errorf("no objects passed to create"))
+				cmdutil.CheckErr(fmt.Errorf("no objects passed to create"))
 			}
 		},
 	}

pkg/kubectl/cmd/delete.go

@@ -66,7 +66,7 @@ func (f *Factory) NewCmdDelete(out io.Writer) *cobra.Command {
 		Example: delete_example,
 		Run: func(cmd *cobra.Command, args []string) {
 			cmdNamespace, err := f.DefaultNamespace(cmd)
-			checkErr(err)
+			cmdutil.CheckErr(err)
 			mapper, typer := f.Object(cmd)
 			r := resource.NewBuilder(mapper, typer, f.ClientMapperForCommand(cmd)).
 				ContinueOnError().
@@ -77,7 +77,7 @@ func (f *Factory) NewCmdDelete(out io.Writer) *cobra.Command {
 				ResourceTypeOrNameArgs(false, args...).
 				Flatten().
 				Do()
-			checkErr(r.Err())
+			cmdutil.CheckErr(r.Err())
 
 			found := 0
 			err = r.IgnoreErrors(errors.IsNotFound).Visit(func(r *resource.Info) error {
@@ -88,7 +88,7 @@ func (f *Factory) NewCmdDelete(out io.Writer) *cobra.Command {
 				fmt.Fprintf(out, "%s\n", r.Name)
 				return nil
 			})
-			checkErr(err)
+			cmdutil.CheckErr(err)
 			if found == 0 {
 				fmt.Fprintf(cmd.Out(), "No resources found\n")
 			}

pkg/kubectl/cmd/describe.go

@@ -34,17 +34,17 @@ This command joins many API calls together to form a detailed description of a
 given resource.`,
 		Run: func(cmd *cobra.Command, args []string) {
 			cmdNamespace, err := f.DefaultNamespace(cmd)
-			checkErr(err)
+			util.CheckErr(err)
 
 			mapper, _ := f.Object(cmd)
 			// TODO: use resource.Builder instead
 			mapping, namespace, name := util.ResourceFromArgs(cmd, args, mapper, cmdNamespace)
 
 			describer, err := f.Describer(cmd, mapping)
-			checkErr(err)
+			util.CheckErr(err)
 
 			s, err := describer.Describe(namespace, name)
-			checkErr(err)
+			util.CheckErr(err)
 			fmt.Fprintf(out, "%s\n", s)
 		},
 	}

pkg/kubectl/cmd/exec.go

@@ -61,13 +61,13 @@ func (f *Factory) NewCmdExec(cmdIn io.Reader, cmdOut, cmdErr io.Writer) *cobra.C
 			}
 
 			namespace, err := f.DefaultNamespace(cmd)
-			checkErr(err)
+			util.CheckErr(err)
 
 			client, err := f.Client(cmd)
-			checkErr(err)
+			util.CheckErr(err)
 
 			pod, err := client.Pods(namespace).Get(flags.pod)
-			checkErr(err)
+			util.CheckErr(err)
 
 			if pod.Status.Phase != api.PodRunning {
 				glog.Fatalf("Unable to execute command because pod is not running. Current status=%v", pod.Status.Phase)
@@ -113,7 +113,7 @@ func (f *Factory) NewCmdExec(cmdIn io.Reader, cmdOut, cmdErr io.Writer) *cobra.C
 			}
 
 			config, err := f.ClientConfig(cmd)
-			checkErr(err)
+			util.CheckErr(err)
 
 			req := client.RESTClient.Get().
 				Prefix("proxy").
@@ -123,7 +123,7 @@ func (f *Factory) NewCmdExec(cmdIn io.Reader, cmdOut, cmdErr io.Writer) *cobra.C
 
 			e := remotecommand.New(req, config, args, stdin, cmdOut, cmdErr, flags.tty)
 			err = e.Execute()
-			checkErr(err)
+			util.CheckErr(err)
 		},
 	}
 	cmd.Flags().StringVarP(&flags.pod, "pod", "p", "", "Pod name")

pkg/kubectl/cmd/expose.go

@@ -51,9 +51,9 @@ func (f *Factory) NewCmdExposeService(out io.Writer) *cobra.Command {
 			}
 
 			namespace, err := f.DefaultNamespace(cmd)
-			checkErr(err)
+			util.CheckErr(err)
 			client, err := f.Client(cmd)
-			checkErr(err)
+			util.CheckErr(err)
 
 			generatorName := util.GetFlagString(cmd, "generator")
 
@@ -73,7 +73,7 @@ func (f *Factory) NewCmdExposeService(out io.Writer) *cobra.Command {
 			}
 			if _, found := params["selector"]; !found {
 				rc, err := client.ReplicationControllers(namespace).Get(args[0])
-				checkErr(err)
+				util.CheckErr(err)
 				params["selector"] = kubectl.MakeLabels(rc.Spec.Selector)
 			}
 			if util.GetFlagBool(cmd, "create-external-load-balancer") {
@@ -81,25 +81,25 @@ func (f *Factory) NewCmdExposeService(out io.Writer) *cobra.Command {
 			}
 
 			err = kubectl.ValidateParams(names, params)
-			checkErr(err)
+			util.CheckErr(err)
 
 			service, err := generator.Generate(params)
-			checkErr(err)
+			util.CheckErr(err)
 
 			inline := util.GetFlagString(cmd, "overrides")
 			if len(inline) > 0 {
 				service, err = util.Merge(service, inline, "Service")
-				checkErr(err)
+				util.CheckErr(err)
 			}
 
 			// TODO: extract this flag to a central location, when such a location exists.
 			if !util.GetFlagBool(cmd, "dry-run") {
 				service, err = client.Services(namespace).Create(service.(*api.Service))
-				checkErr(err)
+				util.CheckErr(err)
 			}
 
 			err = f.PrintObject(cmd, service, out)
-			checkErr(err)
+			util.CheckErr(err)
 		},
 	}
 	util.AddPrinterFlags(cmd)

pkg/kubectl/cmd/get.go

@@ -81,7 +81,7 @@ func RunGet(f *Factory, out io.Writer, cmd *cobra.Command, args []string) {
 	mapper, typer := f.Object(cmd)
 
 	cmdNamespace, err := f.DefaultNamespace(cmd)
-	checkErr(err)
+	util.CheckErr(err)
 
 	// handle watch separately since we cannot watch multiple resource types
 	isWatch, isWatchOnly := util.GetFlagBool(cmd, "watch"), util.GetFlagBool(cmd, "watch-only")
@@ -92,30 +92,30 @@ func RunGet(f *Factory, out io.Writer, cmd *cobra.Command, args []string) {
 			ResourceTypeOrNameArgs(true, args...).
 			SingleResourceType().
 			Do()
-		checkErr(r.Err())
+		util.CheckErr(r.Err())
 
 		mapping, err := r.ResourceMapping()
-		checkErr(err)
+		util.CheckErr(err)
 
 		printer, err := f.PrinterForMapping(cmd, mapping)
-		checkErr(err)
+		util.CheckErr(err)
 
 		obj, err := r.Object()
-		checkErr(err)
+		util.CheckErr(err)
 
 		rv, err := mapping.MetadataAccessor.ResourceVersion(obj)
-		checkErr(err)
+		util.CheckErr(err)
 
 		// print the current object
 		if !isWatchOnly {
 			if err := printer.PrintObj(obj, out); err != nil {
-				checkErr(fmt.Errorf("unable to output the provided object: %v", err))
+				util.CheckErr(fmt.Errorf("unable to output the provided object: %v", err))
 			}
 		}
 
 		// print watched changes
 		w, err := r.Watch(rv)
-		checkErr(err)
+		util.CheckErr(err)
 
 		kubectl.WatchLoop(w, func(e watch.Event) error {
 			return printer.PrintObj(e.Object, out)
@@ -129,11 +129,11 @@ func RunGet(f *Factory, out io.Writer, cmd *cobra.Command, args []string) {
 		ResourceTypeOrNameArgs(true, args...).
 		Latest()
 	printer, generic, err := util.PrinterForCommand(cmd)
-	checkErr(err)
+	util.CheckErr(err)
 
 	if generic {
 		clientConfig, err := f.ClientConfig(cmd)
-		checkErr(err)
+		util.CheckErr(err)
 		defaultVersion := clientConfig.Version
 
 		// the outermost object will be converted to the output-version
@@ -141,7 +141,7 @@ func RunGet(f *Factory, out io.Writer, cmd *cobra.Command, args []string) {
 
 		r := b.Flatten().Do()
 		obj, err := r.Object()
-		checkErr(err)
+		util.CheckErr(err)
 
 		// try conversion to all the possible versions
 		// TODO: simplify by adding a ResourceBuilder mode
@@ -158,7 +158,7 @@ func RunGet(f *Factory, out io.Writer, cmd *cobra.Command, args []string) {
 		printer := kubectl.NewVersionedPrinter(printer, api.Scheme, versions...)
 
 		err = printer.PrintObj(obj, out)
-		checkErr(err)
+		util.CheckErr(err)
 		return
 	}
 
@@ -170,5 +170,5 @@ func RunGet(f *Factory, out io.Writer, cmd *cobra.Command, args []string) {
 		}
 		return printer.PrintObj(r.Object, out)
 	})
-	checkErr(err)
+	util.CheckErr(err)
 }

pkg/kubectl/cmd/label.go

@@ -63,28 +63,28 @@ func (f *Factory) NewCmdLabel(out io.Writer) *cobra.Command {
 			}
 			res := args[:2]
 			cmdNamespace, err := f.DefaultNamespace(cmd)
-			checkErr(err)
+			util.CheckErr(err)
 
 			mapper, _ := f.Object(cmd)
 			// TODO: use resource.Builder instead
 			mapping, namespace, name := util.ResourceFromArgs(cmd, res, mapper, cmdNamespace)
 			client, err := f.RESTClient(cmd, mapping)
-			checkErr(err)
+			util.CheckErr(err)
 
 			labels, remove, err := parseLabels(args[2:])
-			checkErr(err)
+			util.CheckErr(err)
 			overwrite := util.GetFlagBool(cmd, "overwrite")
 			resourceVersion := util.GetFlagString(cmd, "resource-version")
 
 			obj, err := updateObject(client, mapping, namespace, name, func(obj runtime.Object) runtime.Object {
 				outObj, err := labelFunc(obj, overwrite, resourceVersion, labels, remove)
-				checkErr(err)
+				util.CheckErr(err)
 				return outObj
 			})
-			checkErr(err)
+			util.CheckErr(err)
 
 			printer, err := f.PrinterForMapping(cmd, mapping)
-			checkErr(err)
+			util.CheckErr(err)
 
 			printer.PrintObj(obj, out)
 		},

pkg/kubectl/cmd/log.go

@@ -74,14 +74,14 @@ func (f *Factory) NewCmdLog(out io.Writer) *cobra.Command {
 			}
 
 			namespace, err := f.DefaultNamespace(cmd)
-			checkErr(err)
+			util.CheckErr(err)
 			client, err := f.Client(cmd)
-			checkErr(err)
+			util.CheckErr(err)
 
 			podID := args[0]
 
 			pod, err := client.Pods(namespace).Get(podID)
-			checkErr(err)
+			util.CheckErr(err)
 
 			var container string
 			if len(args) == 1 {
@@ -111,11 +111,11 @@ func (f *Factory) NewCmdLog(out io.Writer) *cobra.Command {
 				Suffix("containerLogs", namespace, podID, container).
 				Param("follow", strconv.FormatBool(follow)).
 				Stream()
-			checkErr(err)
+			util.CheckErr(err)
 
 			defer readCloser.Close()
 			_, err = io.Copy(out, readCloser)
-			checkErr(err)
+			util.CheckErr(err)
 		},
 	}
 	cmd.Flags().BoolP("follow", "f", false, "Specify if the logs should be streamed.")

pkg/kubectl/cmd/portforward.go

@@ -22,6 +22,7 @@ import (
 
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/client/portforward"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/kubectl/cmd/util"
 	"github.com/golang/glog"
 	"github.com/spf13/cobra"
 )
@@ -61,20 +62,20 @@ func (f *Factory) NewCmdPortForward() *cobra.Command {
 			}
 
 			namespace, err := f.DefaultNamespace(cmd)
-			checkErr(err)
+			util.CheckErr(err)
 
 			client, err := f.Client(cmd)
-			checkErr(err)
+			util.CheckErr(err)
 
 			pod, err := client.Pods(namespace).Get(flags.pod)
-			checkErr(err)
+			util.CheckErr(err)
 
 			if pod.Status.Phase != api.PodRunning {
 				glog.Fatalf("Unable to execute command because pod is not running. Current status=%v", pod.Status.Phase)
 			}
 
 			config, err := f.ClientConfig(cmd)
-			checkErr(err)
+			util.CheckErr(err)
 
 			signals := make(chan os.Signal, 1)
 			signal.Notify(signals, os.Interrupt)
@@ -93,10 +94,10 @@ func (f *Factory) NewCmdPortForward() *cobra.Command {
 				Suffix("portForward", namespace, flags.pod)
 
 			pf, err := portforward.New(req, config, args, stopCh)
-			checkErr(err)
+			util.CheckErr(err)
 
 			err = pf.ForwardPorts()
-			checkErr(err)
+			util.CheckErr(err)
 		},
 	}
 	cmd.Flags().StringVarP(&flags.pod, "pod", "p", "", "Pod name")

pkg/kubectl/cmd/proxy.go

@@ -36,7 +36,7 @@ func (f *Factory) NewCmdProxy(out io.Writer) *cobra.Command {
 			glog.Infof("Starting to serve on localhost:%d", port)
 
 			clientConfig, err := f.ClientConfig(cmd)
-			checkErr(err)
+			util.CheckErr(err)
 
 			staticPrefix := util.GetFlagString(cmd, "www-prefix")
 			if !strings.HasSuffix(staticPrefix, "/") {
@@ -49,7 +49,7 @@ func (f *Factory) NewCmdProxy(out io.Writer) *cobra.Command {
 			}
 			server, err := kubectl.NewProxyServer(util.GetFlagString(cmd, "www"), apiProxyPrefix, staticPrefix, clientConfig)
 
-			checkErr(err)
+			util.CheckErr(err)
 			glog.Fatal(server.Serve(port))
 		},
 	}

pkg/kubectl/cmd/resize.go

@@ -58,14 +58,14 @@ func (f *Factory) NewCmdResize(out io.Writer) *cobra.Command {
 			}
 
 			cmdNamespace, err := f.DefaultNamespace(cmd)
-			checkErr(err)
+			util.CheckErr(err)
 
 			mapper, _ := f.Object(cmd)
 			// TODO: use resource.Builder instead
 			mapping, namespace, name := util.ResourceFromArgs(cmd, args, mapper, cmdNamespace)
 
 			resizer, err := f.Resizer(cmd, mapping)
-			checkErr(err)
+			util.CheckErr(err)
 
 			resourceVersion := util.GetFlagString(cmd, "resource-version")
 			currentSize := util.GetFlagInt(cmd, "current-replicas")
@@ -75,7 +75,7 @@ func (f *Factory) NewCmdResize(out io.Writer) *cobra.Command {
 			msg := "resized"
 			if err = wait.Poll(retryFrequency, retryTimeout, cond); err != nil {
 				msg = fmt.Sprintf("Failed to resize controller in spite of retrying for %s", retryTimeout)
-				checkErr(err)
+				util.CheckErr(err)
 			}
 			fmt.Fprintf(out, "%s\n", msg)
 		},

pkg/kubectl/cmd/rollingupdate.go

@@ -61,10 +61,10 @@ func (f *Factory) NewCmdRollingUpdate(out io.Writer) *cobra.Command {
 			}
 			oldName := args[0]
 			schema, err := f.Validator(cmd)
-			checkErr(err)
+			util.CheckErr(err)
 
 			clientConfig, err := f.ClientConfig(cmd)
-			checkErr(err)
+			util.CheckErr(err)
 			cmdApiVersion := clientConfig.Version
 
 			mapper, typer := f.Object(cmd)
@@ -79,23 +79,23 @@ func (f *Factory) NewCmdRollingUpdate(out io.Writer) *cobra.Command {
 			}
 
 			cmdNamespace, err := f.DefaultNamespace(cmd)
-			checkErr(err)
+			util.CheckErr(err)
 			// TODO: use resource.Builder instead
 			err = util.CompareNamespace(cmdNamespace, namespace)
-			checkErr(err)
+			util.CheckErr(err)
 
 			client, err := f.Client(cmd)
-			checkErr(err)
+			util.CheckErr(err)
 
 			obj, err := mapping.Codec.Decode(data)
-			checkErr(err)
+			util.CheckErr(err)
 			newRc := obj.(*api.ReplicationController)
 
 			updater := kubectl.NewRollingUpdater(cmdNamespace, client)
 
 			// fetch rc
 			oldRc, err := client.ReplicationControllers(cmdNamespace).Get(oldName)
-			checkErr(err)
+			util.CheckErr(err)
 
 			var hasLabel bool
 			for key, oldValue := range oldRc.Spec.Selector {
@@ -113,7 +113,7 @@ func (f *Factory) NewCmdRollingUpdate(out io.Writer) *cobra.Command {
 				newRc.Spec.Replicas = oldRc.Spec.Replicas
 			}
 			err = updater.Update(out, oldRc, newRc, period, interval, timeout)
-			checkErr(err)
+			util.CheckErr(err)
 
 			fmt.Fprintf(out, "%s\n", newName)
 		},

pkg/kubectl/cmd/run.go

@@ -54,10 +54,10 @@ func (f *Factory) NewCmdRunContainer(out io.Writer) *cobra.Command {
 			}
 
 			namespace, err := f.DefaultNamespace(cmd)
-			checkErr(err)
+			util.CheckErr(err)
 
 			client, err := f.Client(cmd)
-			checkErr(err)
+			util.CheckErr(err)
 
 			generatorName := util.GetFlagString(cmd, "generator")
 			generator, found := kubectl.Generators[generatorName]
@@ -69,25 +69,25 @@ func (f *Factory) NewCmdRunContainer(out io.Writer) *cobra.Command {
 			params["name"] = args[0]
 
 			err = kubectl.ValidateParams(names, params)
-			checkErr(err)
+			util.CheckErr(err)
 
 			controller, err := generator.Generate(params)
-			checkErr(err)
+			util.CheckErr(err)
 
 			inline := util.GetFlagString(cmd, "overrides")
 			if len(inline) > 0 {
 				controller, err = util.Merge(controller, inline, "ReplicationController")
-				checkErr(err)
+				util.CheckErr(err)
 			}
 
 			// TODO: extract this flag to a central location, when such a location exists.
 			if !util.GetFlagBool(cmd, "dry-run") {
 				controller, err = client.ReplicationControllers(namespace).Create(controller.(*api.ReplicationController))
-				checkErr(err)
+				util.CheckErr(err)
 			}
 
 			err = f.PrintObject(cmd, controller, out)
-			checkErr(err)
+			util.CheckErr(err)
 		},
 	}
 	util.AddPrinterFlags(cmd)

pkg/kubectl/cmd/stop.go

@@ -20,6 +20,7 @@ import (
 	"fmt"
 	"io"
 
+	cmdutil "github.com/GoogleCloudPlatform/kubernetes/pkg/kubectl/cmd/util"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/kubectl/resource"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
 	"github.com/spf13/cobra"
@@ -51,7 +52,7 @@ func (f *Factory) NewCmdStop(out io.Writer) *cobra.Command {
 		Example: stop_example,
 		Run: func(cmd *cobra.Command, args []string) {
 			cmdNamespace, err := f.DefaultNamespace(cmd)
-			checkErr(err)
+			cmdutil.CheckErr(err)
 			mapper, typer := f.Object(cmd)
 			r := resource.NewBuilder(mapper, typer, f.ClientMapperForCommand(cmd)).
 				ContinueOnError().
@@ -60,11 +61,11 @@ func (f *Factory) NewCmdStop(out io.Writer) *cobra.Command {
 				FilenameParam(flags.Filenames...).
 				Flatten().
 				Do()
-			checkErr(r.Err())
+			cmdutil.CheckErr(r.Err())
 
 			r.Visit(func(info *resource.Info) error {
 				reaper, err := f.Reaper(cmd, info.Mapping)
-				checkErr(err)
+				cmdutil.CheckErr(err)
 				s, err := reaper.Stop(info.Namespace, info.Name)
 				if err != nil {
 					return err

pkg/kubectl/cmd/update.go

@@ -51,10 +51,10 @@ func (f *Factory) NewCmdUpdate(out io.Writer) *cobra.Command {
 		Example: update_example,
 		Run: func(cmd *cobra.Command, args []string) {
 			schema, err := f.Validator(cmd)
-			checkErr(err)
+			cmdutil.CheckErr(err)
 
 			cmdNamespace, err := f.DefaultNamespace(cmd)
-			checkErr(err)
+			cmdutil.CheckErr(err)
 
 			patch := cmdutil.GetFlagString(cmd, "patch")
 			if len(flags.Filenames) == 0 && len(patch) == 0 {
@@ -78,7 +78,7 @@ func (f *Factory) NewCmdUpdate(out io.Writer) *cobra.Command {
 				FilenameParam(flags.Filenames...).
 				Flatten().
 				Do()
-			checkErr(r.Err())
+			cmdutil.CheckErr(r.Err())
 
 			err = r.Visit(func(info *resource.Info) error {
 				data, err := info.Mapping.Codec.Encode(info.Object)
@@ -96,7 +96,7 @@ func (f *Factory) NewCmdUpdate(out io.Writer) *cobra.Command {
 				fmt.Fprintf(out, "%s\n", info.Name)
 				return nil
 			})
-			checkErr(err)
+			cmdutil.CheckErr(err)
 
 		},
 	}
@@ -107,25 +107,25 @@ func (f *Factory) NewCmdUpdate(out io.Writer) *cobra.Command {
 
 func updateWithPatch(cmd *cobra.Command, args []string, f *Factory, patch string) string {
 	cmdNamespace, err := f.DefaultNamespace(cmd)
-	checkErr(err)
+	cmdutil.CheckErr(err)
 
 	mapper, _ := f.Object(cmd)
 	// TODO: use resource.Builder instead
 	mapping, namespace, name := cmdutil.ResourceFromArgs(cmd, args, mapper, cmdNamespace)
 	client, err := f.RESTClient(cmd, mapping)
-	checkErr(err)
+	cmdutil.CheckErr(err)
 
 	helper := resource.NewHelper(client, mapping)
 	obj, err := helper.Get(namespace, name)
-	checkErr(err)
+	cmdutil.CheckErr(err)
 
 	patchedObj, err := cmdutil.Merge(obj, patch, mapping.Kind)
-	checkErr(err)
+	cmdutil.CheckErr(err)
 
 	data, err := helper.Codec.Encode(patchedObj)
-	checkErr(err)
+	cmdutil.CheckErr(err)
 
 	_, err = helper.Update(namespace, name, true, data)
-	checkErr(err)
+	cmdutil.CheckErr(err)
 	return name
 }

pkg/kubectl/cmd/util/helpers.go

@@ -26,7 +26,9 @@ import (
 	"strings"
 	"time"
 
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/api/errors"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/api/latest"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/client"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/runtime"
 
 	"github.com/evanphx/json-patch"
@@ -34,9 +36,18 @@ import (
 	"github.com/spf13/cobra"
 )
 
-func checkErr(err error) {
+func CheckErr(err error) {
 	if err != nil {
-		glog.FatalDepth(1, err.Error())
+		if errors.IsStatusError(err) {
+			glog.FatalDepth(1, fmt.Sprintf("Error received from API: %s", err.Error()))
+		}
+		if errors.IsUnexpectedObjectError(err) {
+			glog.FatalDepth(1, fmt.Sprintf("Unexpected object received from server: %s", err.Error()))
+		}
+		if client.IsUnexpectedStatusError(err) {
+			glog.FatalDepth(1, fmt.Sprintf("Unexpected status received from server: %s", err.Error()))
+		}
+		glog.FatalDepth(1, fmt.Sprintf("Client error processing command: %s", err.Error()))
 	}
 }
 
@@ -75,7 +86,7 @@ func GetFlagInt(cmd *cobra.Command, flag string) int {
 	v, err := strconv.Atoi(f.Value.String())
 	// This is likely not a sufficiently friendly error message, but cobra
 	// should prevent non-integer values from reaching here.
-	checkErr(err)
+	CheckErr(err)
 	return v
 }
 
@@ -85,7 +96,7 @@ func GetFlagDuration(cmd *cobra.Command, flag string) time.Duration {
 		glog.Fatalf("Flag accessed but not defined for command %s: %s", cmd.Name(), flag)
 	}
 	v, err := time.ParseDuration(f.Value.String())
-	checkErr(err)
+	CheckErr(err)
 	return v
 }
 

pkg/kubectl/cmd/util/resource.go

@@ -43,10 +43,10 @@ func ResourceFromArgs(cmd *cobra.Command, args []string, mapper meta.RESTMapper,
 	}
 
 	version, kind, err := mapper.VersionAndKindForResource(resource)
-	checkErr(err)
+	CheckErr(err)
 
 	mapping, err = mapper.RESTMapping(kind, version)
-	checkErr(err)
+	CheckErr(err)
 	return
 }
 
@@ -56,37 +56,37 @@ func ResourceFromArgs(cmd *cobra.Command, args []string, mapper meta.RESTMapper,
 // DEPRECATED: Use resource.Builder
 func ResourceFromFile(filename string, typer runtime.ObjectTyper, mapper meta.RESTMapper, schema validation.Schema, cmdVersion string) (mapping *meta.RESTMapping, namespace, name string, data []byte) {
 	configData, err := ReadConfigData(filename)
-	checkErr(err)
+	CheckErr(err)
 	data = configData
 
 	objVersion, kind, err := typer.DataVersionAndKind(data)
-	checkErr(err)
+	CheckErr(err)
 
 	// TODO: allow unversioned objects?
 	if len(objVersion) == 0 {
-		checkErr(fmt.Errorf("the resource in the provided file has no apiVersion defined"))
+		CheckErr(fmt.Errorf("the resource in the provided file has no apiVersion defined"))
 	}
 
 	err = schema.ValidateBytes(data)
-	checkErr(err)
+	CheckErr(err)
 
 	// decode using the version stored with the object (allows codec to vary across versions)
 	mapping, err = mapper.RESTMapping(kind, objVersion)
-	checkErr(err)
+	CheckErr(err)
 
 	obj, err := mapping.Codec.Decode(data)
-	checkErr(err)
+	CheckErr(err)
 
 	meta := mapping.MetadataAccessor
 	namespace, err = meta.Namespace(obj)
-	checkErr(err)
+	CheckErr(err)
 	name, err = meta.Name(obj)
-	checkErr(err)
+	CheckErr(err)
 
 	// if the preferred API version differs, get a different mapper
 	if cmdVersion != objVersion {
 		mapping, err = mapper.RESTMapping(kind, cmdVersion)
-		checkErr(err)
+		CheckErr(err)
 	}
 
 	return

pkg/kubectl/cmd/version.go

@@ -36,7 +36,7 @@ func (f *Factory) NewCmdVersion(out io.Writer) *cobra.Command {
 			}
 
 			client, err := f.Client(cmd)
-			checkErr(err)
+			util.CheckErr(err)
 
 			kubectl.GetVersion(out, client)
 		},