github
/
k3s
mirror of https://github.com/k3s-io/k3s
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Differentiate between server error messages and client error messages in kubectl

pull/6/head
Brendan Burns 2015-03-03 16:24:29 -08:00
parent 53ec66caf4
commit f505a33998
22 changed files with 142 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
pkg/api/errors/errors.go
View File

@ -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:

9
pkg/client/request.go
View File

@ -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),

5
pkg/kubectl/cmd/clusterinfo.go
View File

@ -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)).

10
pkg/kubectl/cmd/cmd.go
View File

@ -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())

11
pkg/kubectl/cmd/create.go
View File

@ -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"))
}
},
}

6
pkg/kubectl/cmd/delete.go
View File

@ -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")
}

6
pkg/kubectl/cmd/describe.go
View File

@ -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)
},
}

10
pkg/kubectl/cmd/exec.go
View File

@ -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")

16
pkg/kubectl/cmd/expose.go
View File

@ -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)

26
pkg/kubectl/cmd/get.go
View File

@ -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)
}

12
pkg/kubectl/cmd/label.go
View File

@ -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)
},

10
pkg/kubectl/cmd/log.go
View File

@ -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.")

13
pkg/kubectl/cmd/portforward.go
View File

@ -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")

4
pkg/kubectl/cmd/proxy.go
View File

@ -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))
},
}

6
pkg/kubectl/cmd/resize.go
View File

@ -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)
},

16
pkg/kubectl/cmd/rollingupdate.go
View File

@ -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)
},

14
pkg/kubectl/cmd/run.go
View File

@ -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)

7
pkg/kubectl/cmd/stop.go
View File

@ -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

20
pkg/kubectl/cmd/update.go
View File

@ -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
}

19
pkg/kubectl/cmd/util/helpers.go
View File

@ -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
}

22
pkg/kubectl/cmd/util/resource.go
View File

@ -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

2
pkg/kubectl/cmd/version.go
View File

@ -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)
},