Implement kubectl autoscale

pkg/kubectl/autoscale.go

@@ -0,0 +1,112 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 kubectl
+
+import (
+	"fmt"
+	"strconv"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+	"k8s.io/kubernetes/pkg/runtime"
+)
+
+const (
+	scaleSubResource = "scale"
+)
+
+type HorizontalPodAutoscalerV1Beta1 struct{}
+
+func (HorizontalPodAutoscalerV1Beta1) ParamNames() []GeneratorParam {
+	return []GeneratorParam{
+		{"default-name", true},
+		{"name", false},
+		{"scaleRef-kind", false},
+		{"scaleRef-namespace", false},
+		{"scaleRef-name", false},
+		{"scaleRef-apiVersion", false},
+		{"scaleRef-subresource", false},
+		{"min", false},
+		{"max", true},
+		{"cpu-percent", false},
+	}
+}
+
+func (HorizontalPodAutoscalerV1Beta1) Generate(genericParams map[string]interface{}) (runtime.Object, error) {
+	params := map[string]string{}
+	for key, value := range genericParams {
+		strVal, isString := value.(string)
+		if !isString {
+			return nil, fmt.Errorf("expected string, saw %v for '%s'", value, key)
+		}
+		params[key] = strVal
+	}
+
+	name, found := params["name"]
+	if !found || len(name) == 0 {
+		name, found = params["default-name"]
+		if !found || len(name) == 0 {
+			return nil, fmt.Errorf("'name' is a required parameter.")
+		}
+	}
+	minString, found := params["min"]
+	min := -1
+	var err error
+	if found {
+		if min, err = strconv.Atoi(minString); err != nil {
+			return nil, err
+		}
+	}
+	maxString, found := params["max"]
+	if !found {
+		return nil, fmt.Errorf("'max' is a required parameter.")
+	}
+	max, err := strconv.Atoi(maxString)
+	if err != nil {
+		return nil, err
+	}
+	cpuString, found := params["cpu-percent"]
+	cpu := -1
+	if found {
+		if cpu, err = strconv.Atoi(cpuString); err != nil {
+			return nil, err
+		}
+	}
+
+	scaler := extensions.HorizontalPodAutoscaler{
+		ObjectMeta: api.ObjectMeta{
+			Name: name,
+		},
+		Spec: extensions.HorizontalPodAutoscalerSpec{
+			ScaleRef: extensions.SubresourceReference{
+				Kind:        params["scaleRef-kind"],
+				Namespace:   params["scaleRef-namespace"],
+				Name:        params["scaleRef-name"],
+				APIVersion:  params["scaleRef-apiVersion"],
+				Subresource: scaleSubResource,
+			},
+			MaxReplicas: max,
+		},
+	}
+	if min > 0 {
+		scaler.Spec.MinReplicas = &min
+	}
+	if cpu >= 0 {
+		scaler.Spec.CPUUtilization = &extensions.CPUTargetUtilization{cpu}
+	}
+	return &scaler, nil
+}

pkg/kubectl/cmd/autoscale.go

@@ -0,0 +1,170 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 cmd
+
+import (
+	"fmt"
+	"io"
+
+	"k8s.io/kubernetes/pkg/kubectl"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/kubectl/resource"
+	"k8s.io/kubernetes/pkg/util/errors"
+
+	"github.com/spf13/cobra"
+)
+
+const (
+	autoscaleLong = `Creates an autoscaler that automatically chooses and sets the number of pods that run in a kubernetes cluster.
+
+Looks up a replication controller by name and creates an autoscaler that uses this replication controller as a reference.
+An autoscaler can automatically increase or decrease number of pods deployed within the system as needed.`
+
+	autoscaleExample = `# Auto scale a replication controller "foo", with the number of pods between 2 to 10, target CPU utilization at a default value that server applies:
+$ kubectl autoscale rc foo --min=2 --max=10
+
+# Auto scale a replication controller "foo", with the number of pods between 1 to 5, target CPU utilization at 80%:
+$ kubectl autoscale rc foo --max=5 --cpu-percent=80`
+)
+
+// TODO: support autoscale for deployments
+func NewCmdAutoscale(f *cmdutil.Factory, out io.Writer) *cobra.Command {
+	filenames := []string{}
+	cmd := &cobra.Command{
+		Use:     "autoscale (-f FILENAME | TYPE NAME | TYPE/NAME) [--min=MINPODS] --max=MAXPODS [--cpu-percent=CPU] [flags]",
+		Short:   "Auto-scale a replication controller",
+		Long:    autoscaleLong,
+		Example: autoscaleExample,
+		Run: func(cmd *cobra.Command, args []string) {
+			err := RunAutoscale(f, out, cmd, args, filenames)
+			cmdutil.CheckErr(err)
+		},
+	}
+	cmdutil.AddPrinterFlags(cmd)
+	cmd.Flags().String("generator", "horizontalpodautoscaler/v1beta1", "The name of the API generator to use. Currently there is only 1 generator.")
+	cmd.Flags().Int("min", -1, "The lower limit for the number of pods that can be set by the autoscaler. If it's not specified or negative, the server will apply a default value.")
+	cmd.Flags().Int("max", -1, "The upper limit for the number of pods that can be set by the autoscaler. Required.")
+	cmd.MarkFlagRequired("max")
+	cmd.Flags().Int("cpu-percent", -1, fmt.Sprintf("The target average CPU utilization (represented as a percent of requested CPU) over all the pods. If it's not specified or negative, the server will apply a default value."))
+	cmd.Flags().String("name", "", "The name for the newly created object. If not specified, the name of the input resource will be used.")
+	cmd.Flags().Bool("dry-run", false, "If true, only print the object that would be sent, without creating it.")
+	usage := "Filename, directory, or URL to a file identifying the resource to get from a server."
+	kubectl.AddJsonFilenameFlag(cmd, &filenames, usage)
+	return cmd
+}
+
+func RunAutoscale(f *cmdutil.Factory, out io.Writer, cmd *cobra.Command, args []string, filenames []string) error {
+	namespace, enforceNamespace, err := f.DefaultNamespace()
+	if err != nil {
+		return err
+	}
+
+	// validate flags
+	if err := validateFlags(cmd); err != nil {
+		return err
+	}
+
+	mapper, typer := f.Object()
+	r := resource.NewBuilder(mapper, typer, f.ClientMapperForCommand()).
+		ContinueOnError().
+		NamespaceParam(namespace).DefaultNamespace().
+		FilenameParam(enforceNamespace, filenames...).
+		ResourceTypeOrNameArgs(false, args...).
+		Flatten().
+		Do()
+	infos, err := r.Infos()
+	if err != nil {
+		return err
+	}
+	if len(infos) > 1 {
+		return fmt.Errorf("multiple resources provided: %v", args)
+	}
+	info := infos[0]
+	mapping := info.ResourceMapping()
+	if err := f.CanBeAutoscaled(mapping.Kind); err != nil {
+		return err
+	}
+
+	// Get the generator, setup and validate all required parameters
+	generatorName := cmdutil.GetFlagString(cmd, "generator")
+	generator, found := f.Generator(generatorName)
+	if !found {
+		return cmdutil.UsageError(cmd, fmt.Sprintf("generator %q not found.", generatorName))
+	}
+	names := generator.ParamNames()
+	params := kubectl.MakeParams(cmd, names)
+	name := info.Name
+	params["default-name"] = name
+
+	params["scaleRef-kind"] = mapping.Kind
+	params["scaleRef-namespace"] = namespace
+	params["scaleRef-name"] = name
+	params["scaleRef-apiVersion"] = mapping.APIVersion
+
+	if err = kubectl.ValidateParams(names, params); err != nil {
+		return err
+	}
+
+	// Generate new object
+	object, err := generator.Generate(params)
+	if err != nil {
+		return err
+	}
+
+	resourceMapper := &resource.Mapper{ObjectTyper: typer, RESTMapper: mapper, ClientMapper: f.ClientMapperForCommand()}
+	hpa, err := resourceMapper.InfoForObject(object)
+	if err != nil {
+		return err
+	}
+	// TODO: extract this flag to a central location, when such a location exists.
+	if cmdutil.GetFlagBool(cmd, "dry-run") {
+		return f.PrintObject(cmd, object, out)
+	}
+
+	// Serialize the configuration into an annotation.
+	if err := kubectl.UpdateApplyAnnotation(hpa); err != nil {
+		return err
+	}
+
+	// Serialize the object with the annotation applied.
+	data, err := hpa.Mapping.Codec.Encode(object)
+	if err != nil {
+		return err
+	}
+	object, err = resource.NewHelper(hpa.Client, hpa.Mapping).Create(namespace, false, data)
+	if err != nil {
+		return err
+	}
+
+	if len(cmdutil.GetFlagString(cmd, "output")) > 0 {
+		return f.PrintObject(cmd, object, out)
+	}
+	cmdutil.PrintSuccess(mapper, false, out, info.Mapping.Resource, info.Name, "autoscaled")
+	return nil
+}
+
+func validateFlags(cmd *cobra.Command) error {
+	errs := []error{}
+	max, min, cpu := cmdutil.GetFlagInt(cmd, "max"), cmdutil.GetFlagInt(cmd, "min"), cmdutil.GetFlagInt(cmd, "cpu-percent")
+	if max < 1 || max < min {
+		errs = append(errs, fmt.Errorf("--max=MAXPODS is required, and must be at least 1 and --min=MINPODS"))
+	}
+	if cpu > 100 {
+		errs = append(errs, fmt.Errorf("CPU utilization (%%) cannot exceed 100"))
+	}
+	return errors.NewAggregate(errs)
+}

pkg/kubectl/cmd/cmd.go

@@ -165,6 +165,7 @@ Find more information at https://github.com/kubernetes/kubernetes.`,
 	cmds.AddCommand(NewCmdRun(f, in, out, err))
 	cmds.AddCommand(NewCmdStop(f, out))
 	cmds.AddCommand(NewCmdExposeService(f, out))
+	cmds.AddCommand(NewCmdAutoscale(f, out))
 
 	cmds.AddCommand(NewCmdLabel(f, out))
 	cmds.AddCommand(NewCmdAnnotate(f, out))

pkg/kubectl/cmd/util/factory.go

@@ -90,6 +90,8 @@ type Factory struct {
 	Generator func(name string) (kubectl.Generator, bool)
 	// Check whether the kind of resources could be exposed
 	CanBeExposed func(kind string) error
+	// Check whether the kind of resources could be autoscaled
+	CanBeAutoscaled func(kind string) error
 }
 
 // NewFactory creates a factory with the default Kubernetes resources defined
@@ -102,10 +104,11 @@ func NewFactory(optionalClientConfig clientcmd.ClientConfig) *Factory {
 	flags.SetNormalizeFunc(util.WarnWordSepNormalizeFunc) // Warn for "_" flags
 
 	generators := map[string]kubectl.Generator{
-		"run/v1":     kubectl.BasicReplicationController{},
-		"run-pod/v1": kubectl.BasicPod{},
-		"service/v1": kubectl.ServiceGeneratorV1{},
-		"service/v2": kubectl.ServiceGeneratorV2{},
+		"run/v1":                          kubectl.BasicReplicationController{},
+		"run-pod/v1":                      kubectl.BasicPod{},
+		"service/v1":                      kubectl.ServiceGeneratorV1{},
+		"service/v2":                      kubectl.ServiceGeneratorV2{},
+		"horizontalpodautoscaler/v1beta1": kubectl.HorizontalPodAutoscalerV1Beta1{},
 	}
 
 	clientConfig := optionalClientConfig
@@ -256,6 +259,12 @@ func NewFactory(optionalClientConfig clientcmd.ClientConfig) *Factory {
 			}
 			return nil
 		},
+		CanBeAutoscaled: func(kind string) error { // TODO: support autoscale for deployments
+			if kind != "ReplicationController" {
+				return fmt.Errorf("invalid resource provided: %v, only a replication controller is accepted", kind)
+			}
+			return nil
+		},
 	}
 }