vendor files

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/rollout/BUILD

@@ -0,0 +1,51 @@
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "rollout.go",
+        "rollout_history.go",
+        "rollout_pause.go",
+        "rollout_resume.go",
+        "rollout_status.go",
+        "rollout_undo.go",
+    ],
+    importpath = "k8s.io/kubernetes/pkg/kubectl/cmd/rollout",
+    visibility = [
+        "//build/visible_to:pkg_kubectl_cmd_rollout_CONSUMERS",
+    ],
+    deps = [
+        "//pkg/kubectl:go_default_library",
+        "//pkg/kubectl/cmd/set:go_default_library",
+        "//pkg/kubectl/cmd/templates:go_default_library",
+        "//pkg/kubectl/cmd/util:go_default_library",
+        "//pkg/kubectl/resource:go_default_library",
+        "//pkg/kubectl/util/i18n:go_default_library",
+        "//pkg/util/interrupt:go_default_library",
+        "//vendor/github.com/renstrom/dedent:go_default_library",
+        "//vendor/github.com/spf13/cobra:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/meta:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/errors:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/watch:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = [
+        "//build/visible_to:pkg_kubectl_cmd_rollout_CONSUMERS",
+    ],
+)

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/rollout/rollout.go

@@ -0,0 +1,66 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package rollout
+
+import (
+	"io"
+
+	"github.com/renstrom/dedent"
+	"github.com/spf13/cobra"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/kubectl/util/i18n"
+)
+
+var (
+	rollout_long = templates.LongDesc(`
+		Manage the rollout of a resource.` + rollout_valid_resources)
+
+	rollout_example = templates.Examples(`
+		# Rollback to the previous deployment
+		kubectl rollout undo deployment/abc
+		
+		# Check the rollout status of a daemonset
+		kubectl rollout status daemonset/foo`)
+
+	rollout_valid_resources = dedent.Dedent(`
+		Valid resource types include:
+
+		   * deployments
+		   * daemonsets
+		   * statefulsets
+		`)
+)
+
+func NewCmdRollout(f cmdutil.Factory, out, errOut io.Writer) *cobra.Command {
+
+	cmd := &cobra.Command{
+		Use:     "rollout SUBCOMMAND",
+		Short:   i18n.T("Manage the rollout of a resource"),
+		Long:    rollout_long,
+		Example: rollout_example,
+		Run:     cmdutil.DefaultSubCommandRun(errOut),
+	}
+	// subcommands
+	cmd.AddCommand(NewCmdRolloutHistory(f, out))
+	cmd.AddCommand(NewCmdRolloutPause(f, out))
+	cmd.AddCommand(NewCmdRolloutResume(f, out))
+	cmd.AddCommand(NewCmdRolloutUndo(f, out))
+	cmd.AddCommand(NewCmdRolloutStatus(f, out))
+
+	return cmd
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/rollout/rollout_history.go

@@ -0,0 +1,118 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package rollout
+
+import (
+	"fmt"
+	"io"
+
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+	"k8s.io/kubernetes/pkg/kubectl/util/i18n"
+
+	"github.com/spf13/cobra"
+)
+
+var (
+	history_long = templates.LongDesc(`
+		View previous rollout revisions and configurations.`)
+
+	history_example = templates.Examples(`
+		# View the rollout history of a deployment
+		kubectl rollout history deployment/abc
+
+		# View the details of daemonset revision 3
+		kubectl rollout history daemonset/abc --revision=3`)
+)
+
+func NewCmdRolloutHistory(f cmdutil.Factory, out io.Writer) *cobra.Command {
+	options := &resource.FilenameOptions{}
+
+	validArgs := []string{"deployment", "daemonset", "statefulset"}
+	argAliases := kubectl.ResourceAliases(validArgs)
+
+	cmd := &cobra.Command{
+		Use:     "history (TYPE NAME | TYPE/NAME) [flags]",
+		Short:   i18n.T("View rollout history"),
+		Long:    history_long,
+		Example: history_example,
+		Run: func(cmd *cobra.Command, args []string) {
+			cmdutil.CheckErr(RunHistory(f, cmd, out, args, options))
+		},
+		ValidArgs:  validArgs,
+		ArgAliases: argAliases,
+	}
+
+	cmd.Flags().Int64("revision", 0, "See the details, including podTemplate of the revision specified")
+	usage := "identifying the resource to get from a server."
+	cmdutil.AddFilenameOptionFlags(cmd, options, usage)
+	return cmd
+}
+
+func RunHistory(f cmdutil.Factory, cmd *cobra.Command, out io.Writer, args []string, options *resource.FilenameOptions) error {
+	if len(args) == 0 && cmdutil.IsFilenameSliceEmpty(options.Filenames) {
+		return cmdutil.UsageErrorf(cmd, "Required resource not specified.")
+	}
+	revision := cmdutil.GetFlagInt64(cmd, "revision")
+	if revision < 0 {
+		return fmt.Errorf("revision must be a positive integer: %v", revision)
+	}
+
+	cmdNamespace, enforceNamespace, err := f.DefaultNamespace()
+	if err != nil {
+		return err
+	}
+
+	r := f.NewBuilder().
+		Internal().
+		NamespaceParam(cmdNamespace).DefaultNamespace().
+		FilenameParam(enforceNamespace, options).
+		ResourceTypeOrNameArgs(true, args...).
+		ContinueOnError().
+		Latest().
+		Flatten().
+		Do()
+	err = r.Err()
+	if err != nil {
+		return err
+	}
+
+	return r.Visit(func(info *resource.Info, err error) error {
+		if err != nil {
+			return err
+		}
+		mapping := info.ResourceMapping()
+		historyViewer, err := f.HistoryViewer(mapping)
+		if err != nil {
+			return err
+		}
+		historyInfo, err := historyViewer.ViewHistory(info.Namespace, info.Name, revision)
+		if err != nil {
+			return err
+		}
+
+		header := fmt.Sprintf("%s %q", mapping.Resource, info.Name)
+		if revision > 0 {
+			header = fmt.Sprintf("%s with revision #%d", header, revision)
+		}
+		fmt.Fprintf(out, "%s\n", header)
+		fmt.Fprintf(out, "%s\n", historyInfo)
+		return nil
+	})
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/rollout/rollout_pause.go

@@ -0,0 +1,162 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package rollout
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/apimachinery/pkg/api/meta"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/types"
+	utilerrors "k8s.io/apimachinery/pkg/util/errors"
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/set"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+	"k8s.io/kubernetes/pkg/kubectl/util/i18n"
+)
+
+// PauseConfig is the start of the data required to perform the operation.  As new fields are added, add them here instead of
+// referencing the cmd.Flags()
+type PauseConfig struct {
+	resource.FilenameOptions
+
+	Pauser  func(info *resource.Info) ([]byte, error)
+	Mapper  meta.RESTMapper
+	Typer   runtime.ObjectTyper
+	Encoder runtime.Encoder
+	Infos   []*resource.Info
+
+	PrintSuccess func(mapper meta.RESTMapper, shortOutput bool, out io.Writer, resource, name string, dryRun bool, operation string)
+	Out          io.Writer
+}
+
+var (
+	pause_long = templates.LongDesc(`
+		Mark the provided resource as paused
+
+		Paused resources will not be reconciled by a controller.
+		Use "kubectl rollout resume" to resume a paused resource.
+		Currently only deployments support being paused.`)
+
+	pause_example = templates.Examples(`
+		# Mark the nginx deployment as paused. Any current state of
+		# the deployment will continue its function, new updates to the deployment will not
+		# have an effect as long as the deployment is paused.
+		kubectl rollout pause deployment/nginx`)
+)
+
+func NewCmdRolloutPause(f cmdutil.Factory, out io.Writer) *cobra.Command {
+	options := &PauseConfig{}
+
+	validArgs := []string{"deployment"}
+	argAliases := kubectl.ResourceAliases(validArgs)
+
+	cmd := &cobra.Command{
+		Use:     "pause RESOURCE",
+		Short:   i18n.T("Mark the provided resource as paused"),
+		Long:    pause_long,
+		Example: pause_example,
+		Run: func(cmd *cobra.Command, args []string) {
+			allErrs := []error{}
+			err := options.CompletePause(f, cmd, out, args)
+			if err != nil {
+				allErrs = append(allErrs, err)
+			}
+			err = options.RunPause()
+			if err != nil {
+				allErrs = append(allErrs, err)
+			}
+			cmdutil.CheckErr(utilerrors.Flatten(utilerrors.NewAggregate(allErrs)))
+		},
+		ValidArgs:  validArgs,
+		ArgAliases: argAliases,
+	}
+
+	usage := "identifying the resource to get from a server."
+	cmdutil.AddFilenameOptionFlags(cmd, &options.FilenameOptions, usage)
+	return cmd
+}
+
+func (o *PauseConfig) CompletePause(f cmdutil.Factory, cmd *cobra.Command, out io.Writer, args []string) error {
+	if len(args) == 0 && cmdutil.IsFilenameSliceEmpty(o.Filenames) {
+		return cmdutil.UsageErrorf(cmd, "%s", cmd.Use)
+	}
+
+	o.PrintSuccess = f.PrintSuccess
+	o.Mapper, o.Typer = f.Object()
+	o.Encoder = f.JSONEncoder()
+
+	o.Pauser = f.Pauser
+	o.Out = out
+
+	cmdNamespace, enforceNamespace, err := f.DefaultNamespace()
+	if err != nil {
+		return err
+	}
+
+	r := f.NewBuilder().
+		Internal().
+		NamespaceParam(cmdNamespace).DefaultNamespace().
+		FilenameParam(enforceNamespace, &o.FilenameOptions).
+		ResourceTypeOrNameArgs(true, args...).
+		ContinueOnError().
+		Latest().
+		Flatten().
+		Do()
+	err = r.Err()
+	if err != nil {
+		return err
+	}
+
+	o.Infos, err = r.Infos()
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (o PauseConfig) RunPause() error {
+	allErrs := []error{}
+	for _, patch := range set.CalculatePatches(o.Infos, o.Encoder, o.Pauser) {
+		info := patch.Info
+		if patch.Err != nil {
+			allErrs = append(allErrs, fmt.Errorf("error: %s %q %v", info.Mapping.Resource, info.Name, patch.Err))
+			continue
+		}
+
+		if string(patch.Patch) == "{}" || len(patch.Patch) == 0 {
+			o.PrintSuccess(o.Mapper, false, o.Out, info.Mapping.Resource, info.Name, false, "already paused")
+			continue
+		}
+
+		obj, err := resource.NewHelper(info.Client, info.Mapping).Patch(info.Namespace, info.Name, types.StrategicMergePatchType, patch.Patch)
+		if err != nil {
+			allErrs = append(allErrs, fmt.Errorf("failed to patch: %v", err))
+			continue
+		}
+
+		info.Refresh(obj, true)
+		o.PrintSuccess(o.Mapper, false, o.Out, info.Mapping.Resource, info.Name, false, "paused")
+	}
+
+	return utilerrors.NewAggregate(allErrs)
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/rollout/rollout_resume.go

@@ -0,0 +1,167 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package rollout
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/apimachinery/pkg/api/meta"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/types"
+	utilerrors "k8s.io/apimachinery/pkg/util/errors"
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/set"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+	"k8s.io/kubernetes/pkg/kubectl/util/i18n"
+)
+
+// ResumeConfig is the start of the data required to perform the operation.  As new fields are added, add them here instead of
+// referencing the cmd.Flags()
+type ResumeConfig struct {
+	resource.FilenameOptions
+
+	Resumer func(object *resource.Info) ([]byte, error)
+	Mapper  meta.RESTMapper
+	Typer   runtime.ObjectTyper
+	Encoder runtime.Encoder
+	Infos   []*resource.Info
+
+	PrintSuccess func(mapper meta.RESTMapper, shortOutput bool, out io.Writer, resource, name string, dryRun bool, operation string)
+	Out          io.Writer
+}
+
+var (
+	resume_long = templates.LongDesc(`
+		Resume a paused resource
+
+		Paused resources will not be reconciled by a controller. By resuming a
+		resource, we allow it to be reconciled again.
+		Currently only deployments support being resumed.`)
+
+	resume_example = templates.Examples(`
+		# Resume an already paused deployment
+		kubectl rollout resume deployment/nginx`)
+)
+
+func NewCmdRolloutResume(f cmdutil.Factory, out io.Writer) *cobra.Command {
+	options := &ResumeConfig{}
+
+	validArgs := []string{"deployment"}
+	argAliases := kubectl.ResourceAliases(validArgs)
+
+	cmd := &cobra.Command{
+		Use:     "resume RESOURCE",
+		Short:   i18n.T("Resume a paused resource"),
+		Long:    resume_long,
+		Example: resume_example,
+		Run: func(cmd *cobra.Command, args []string) {
+			allErrs := []error{}
+			err := options.CompleteResume(f, cmd, out, args)
+			if err != nil {
+				allErrs = append(allErrs, err)
+			}
+			err = options.RunResume()
+			if err != nil {
+				allErrs = append(allErrs, err)
+			}
+			cmdutil.CheckErr(utilerrors.Flatten(utilerrors.NewAggregate(allErrs)))
+		},
+		ValidArgs:  validArgs,
+		ArgAliases: argAliases,
+	}
+
+	usage := "identifying the resource to get from a server."
+	cmdutil.AddFilenameOptionFlags(cmd, &options.FilenameOptions, usage)
+	return cmd
+}
+
+func (o *ResumeConfig) CompleteResume(f cmdutil.Factory, cmd *cobra.Command, out io.Writer, args []string) error {
+	if len(args) == 0 && cmdutil.IsFilenameSliceEmpty(o.Filenames) {
+		return cmdutil.UsageErrorf(cmd, "%s", cmd.Use)
+	}
+
+	o.PrintSuccess = f.PrintSuccess
+	o.Mapper, o.Typer = f.Object()
+	o.Encoder = f.JSONEncoder()
+
+	o.Resumer = f.Resumer
+	o.Out = out
+
+	cmdNamespace, enforceNamespace, err := f.DefaultNamespace()
+	if err != nil {
+		return err
+	}
+
+	r := f.NewBuilder().
+		Internal().
+		NamespaceParam(cmdNamespace).DefaultNamespace().
+		FilenameParam(enforceNamespace, &o.FilenameOptions).
+		ResourceTypeOrNameArgs(true, args...).
+		ContinueOnError().
+		Latest().
+		Flatten().
+		Do()
+	err = r.Err()
+	if err != nil {
+		return err
+	}
+
+	err = r.Visit(func(info *resource.Info, err error) error {
+		if err != nil {
+			return err
+		}
+		o.Infos = append(o.Infos, info)
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (o ResumeConfig) RunResume() error {
+	allErrs := []error{}
+	for _, patch := range set.CalculatePatches(o.Infos, o.Encoder, o.Resumer) {
+		info := patch.Info
+
+		if patch.Err != nil {
+			allErrs = append(allErrs, fmt.Errorf("error: %s %q %v", info.Mapping.Resource, info.Name, patch.Err))
+			continue
+		}
+
+		if string(patch.Patch) == "{}" || len(patch.Patch) == 0 {
+			o.PrintSuccess(o.Mapper, false, o.Out, info.Mapping.Resource, info.Name, false, "already resumed")
+			continue
+		}
+
+		obj, err := resource.NewHelper(info.Client, info.Mapping).Patch(info.Namespace, info.Name, types.StrategicMergePatchType, patch.Patch)
+		if err != nil {
+			allErrs = append(allErrs, fmt.Errorf("failed to patch: %v", err))
+			continue
+		}
+
+		info.Refresh(obj, true)
+		o.PrintSuccess(o.Mapper, false, o.Out, info.Mapping.Resource, info.Name, false, "resumed")
+	}
+
+	return utilerrors.NewAggregate(allErrs)
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/rollout/rollout_status.go

@@ -0,0 +1,166 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package rollout
+
+import (
+	"fmt"
+	"io"
+
+	"k8s.io/apimachinery/pkg/watch"
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+	"k8s.io/kubernetes/pkg/kubectl/util/i18n"
+	"k8s.io/kubernetes/pkg/util/interrupt"
+
+	"github.com/spf13/cobra"
+)
+
+var (
+	status_long = templates.LongDesc(`
+		Show the status of the rollout.
+
+		By default 'rollout status' will watch the status of the latest rollout
+		until it's done. If you don't want to wait for the rollout to finish then
+		you can use --watch=false. Note that if a new rollout starts in-between, then
+		'rollout status' will continue watching the latest revision. If you want to
+		pin to a specific revision and abort if it is rolled over by another revision,
+		use --revision=N where N is the revision you need to watch for.`)
+
+	status_example = templates.Examples(`
+		# Watch the rollout status of a deployment
+		kubectl rollout status deployment/nginx`)
+)
+
+func NewCmdRolloutStatus(f cmdutil.Factory, out io.Writer) *cobra.Command {
+	options := &resource.FilenameOptions{}
+
+	validArgs := []string{"deployment", "daemonset", "statefulset"}
+	argAliases := kubectl.ResourceAliases(validArgs)
+
+	cmd := &cobra.Command{
+		Use:     "status (TYPE NAME | TYPE/NAME) [flags]",
+		Short:   i18n.T("Show the status of the rollout"),
+		Long:    status_long,
+		Example: status_example,
+		Run: func(cmd *cobra.Command, args []string) {
+			cmdutil.CheckErr(RunStatus(f, cmd, out, args, options))
+		},
+		ValidArgs:  validArgs,
+		ArgAliases: argAliases,
+	}
+
+	usage := "identifying the resource to get from a server."
+	cmdutil.AddFilenameOptionFlags(cmd, options, usage)
+	cmd.Flags().BoolP("watch", "w", true, "Watch the status of the rollout until it's done.")
+	cmd.Flags().Int64("revision", 0, "Pin to a specific revision for showing its status. Defaults to 0 (last revision).")
+	return cmd
+}
+
+func RunStatus(f cmdutil.Factory, cmd *cobra.Command, out io.Writer, args []string, options *resource.FilenameOptions) error {
+	if len(args) == 0 && cmdutil.IsFilenameSliceEmpty(options.Filenames) {
+		return cmdutil.UsageErrorf(cmd, "Required resource not specified.")
+	}
+
+	cmdNamespace, enforceNamespace, err := f.DefaultNamespace()
+	if err != nil {
+		return err
+	}
+
+	r := f.NewBuilder().
+		Internal().
+		NamespaceParam(cmdNamespace).DefaultNamespace().
+		FilenameParam(enforceNamespace, options).
+		ResourceTypeOrNameArgs(true, args...).
+		SingleResourceType().
+		Latest().
+		Do()
+	err = r.Err()
+	if err != nil {
+		return err
+	}
+
+	infos, err := r.Infos()
+	if err != nil {
+		return err
+	}
+	if len(infos) != 1 {
+		return fmt.Errorf("rollout status is only supported on individual resources and resource collections - %d resources were found", len(infos))
+	}
+	info := infos[0]
+	mapping := info.ResourceMapping()
+
+	obj, err := r.Object()
+	if err != nil {
+		return err
+	}
+	rv, err := mapping.MetadataAccessor.ResourceVersion(obj)
+	if err != nil {
+		return err
+	}
+
+	statusViewer, err := f.StatusViewer(mapping)
+	if err != nil {
+		return err
+	}
+
+	revision := cmdutil.GetFlagInt64(cmd, "revision")
+	if revision < 0 {
+		return fmt.Errorf("revision must be a positive integer: %v", revision)
+	}
+
+	// check if deployment's has finished the rollout
+	status, done, err := statusViewer.Status(cmdNamespace, info.Name, revision)
+	if err != nil {
+		return err
+	}
+	fmt.Fprintf(out, "%s", status)
+	if done {
+		return nil
+	}
+
+	shouldWatch := cmdutil.GetFlagBool(cmd, "watch")
+	if !shouldWatch {
+		return nil
+	}
+
+	// watch for changes to the deployment
+	w, err := r.Watch(rv)
+	if err != nil {
+		return err
+	}
+
+	// if the rollout isn't done yet, keep watching deployment status
+	intr := interrupt.New(nil, w.Stop)
+	return intr.Run(func() error {
+		_, err := watch.Until(0, w, func(e watch.Event) (bool, error) {
+			// print deployment's status
+			status, done, err := statusViewer.Status(cmdNamespace, info.Name, revision)
+			if err != nil {
+				return false, err
+			}
+			fmt.Fprintf(out, "%s", status)
+			// Quit waiting if the rollout is done
+			if done {
+				return true, nil
+			}
+			return false, nil
+		})
+		return err
+	})
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/rollout/rollout_undo.go

@@ -0,0 +1,155 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package rollout
+
+import (
+	"io"
+
+	"k8s.io/apimachinery/pkg/api/meta"
+	"k8s.io/apimachinery/pkg/runtime"
+	utilerrors "k8s.io/apimachinery/pkg/util/errors"
+	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+	"k8s.io/kubernetes/pkg/kubectl/util/i18n"
+
+	"github.com/spf13/cobra"
+)
+
+// UndoOptions is the start of the data required to perform the operation.  As new fields are added, add them here instead of
+// referencing the cmd.Flags()
+type UndoOptions struct {
+	resource.FilenameOptions
+
+	Rollbackers []kubectl.Rollbacker
+	Mapper      meta.RESTMapper
+	Typer       runtime.ObjectTyper
+	Infos       []*resource.Info
+	ToRevision  int64
+	DryRun      bool
+
+	PrintSuccess func(mapper meta.RESTMapper, shortOutput bool, out io.Writer, resource, name string, dryRun bool, operation string)
+	Out          io.Writer
+}
+
+var (
+	undo_long = templates.LongDesc(`
+		Rollback to a previous rollout.`)
+
+	undo_example = templates.Examples(`
+		# Rollback to the previous deployment
+		kubectl rollout undo deployment/abc
+
+		# Rollback to daemonset revision 3
+		kubectl rollout undo daemonset/abc --to-revision=3
+
+		# Rollback to the previous deployment with dry-run
+		kubectl rollout undo --dry-run=true deployment/abc`)
+)
+
+func NewCmdRolloutUndo(f cmdutil.Factory, out io.Writer) *cobra.Command {
+	options := &UndoOptions{}
+
+	validArgs := []string{"deployment", "daemonset", "statefulset"}
+	argAliases := kubectl.ResourceAliases(validArgs)
+
+	cmd := &cobra.Command{
+		Use:     "undo (TYPE NAME | TYPE/NAME) [flags]",
+		Short:   i18n.T("Undo a previous rollout"),
+		Long:    undo_long,
+		Example: undo_example,
+		Run: func(cmd *cobra.Command, args []string) {
+			allErrs := []error{}
+			err := options.CompleteUndo(f, cmd, out, args)
+			if err != nil {
+				allErrs = append(allErrs, err)
+			}
+			err = options.RunUndo()
+			if err != nil {
+				allErrs = append(allErrs, err)
+			}
+			cmdutil.CheckErr(utilerrors.Flatten(utilerrors.NewAggregate(allErrs)))
+		},
+		ValidArgs:  validArgs,
+		ArgAliases: argAliases,
+	}
+
+	cmd.Flags().Int64("to-revision", 0, "The revision to rollback to. Default to 0 (last revision).")
+	usage := "identifying the resource to get from a server."
+	cmdutil.AddFilenameOptionFlags(cmd, &options.FilenameOptions, usage)
+	cmdutil.AddDryRunFlag(cmd)
+	return cmd
+}
+
+func (o *UndoOptions) CompleteUndo(f cmdutil.Factory, cmd *cobra.Command, out io.Writer, args []string) error {
+	if len(args) == 0 && cmdutil.IsFilenameSliceEmpty(o.Filenames) {
+		return cmdutil.UsageErrorf(cmd, "Required resource not specified.")
+	}
+
+	o.PrintSuccess = f.PrintSuccess
+	o.ToRevision = cmdutil.GetFlagInt64(cmd, "to-revision")
+	o.Mapper, o.Typer = f.Object()
+	o.Out = out
+	o.DryRun = cmdutil.GetFlagBool(cmd, "dry-run")
+
+	cmdNamespace, enforceNamespace, err := f.DefaultNamespace()
+	if err != nil {
+		return err
+	}
+
+	r := f.NewBuilder().
+		Internal().
+		NamespaceParam(cmdNamespace).DefaultNamespace().
+		FilenameParam(enforceNamespace, &o.FilenameOptions).
+		ResourceTypeOrNameArgs(true, args...).
+		ContinueOnError().
+		Latest().
+		Flatten().
+		Do()
+	err = r.Err()
+	if err != nil {
+		return err
+	}
+
+	err = r.Visit(func(info *resource.Info, err error) error {
+		if err != nil {
+			return err
+		}
+		rollbacker, err := f.Rollbacker(info.ResourceMapping())
+		if err != nil {
+			return err
+		}
+		o.Infos = append(o.Infos, info)
+		o.Rollbackers = append(o.Rollbackers, rollbacker)
+		return nil
+	})
+	return err
+}
+
+func (o *UndoOptions) RunUndo() error {
+	allErrs := []error{}
+	for ix, info := range o.Infos {
+		result, err := o.Rollbackers[ix].Rollback(info.Object, nil, o.ToRevision, o.DryRun)
+		if err != nil {
+			allErrs = append(allErrs, cmdutil.AddSourceToErr("undoing", info.Source, err))
+			continue
+		}
+		o.PrintSuccess(o.Mapper, false, o.Out, info.Mapping.Resource, info.Name, false, result)
+	}
+	return utilerrors.NewAggregate(allErrs)
+}