diff --git a/hack/verify-flags/known-flags.txt b/hack/verify-flags/known-flags.txt index f7b86694d46..678db563bf6 100644 --- a/hack/verify-flags/known-flags.txt +++ b/hack/verify-flags/known-flags.txt @@ -196,6 +196,7 @@ grace-period ha-domain hairpin-mode hard-pod-affinity-symmetric-weight +hard healthz-bind-address healthz-port horizontal-pod-autoscaler-sync-period diff --git a/pkg/kubectl/cmd/create.go b/pkg/kubectl/cmd/create.go index a2638dcf960..53cb68bd5a4 100644 --- a/pkg/kubectl/cmd/create.go +++ b/pkg/kubectl/cmd/create.go @@ -80,6 +80,7 @@ func NewCmdCreate(f *cmdutil.Factory, out io.Writer) *cobra.Command { // create subcommands cmd.AddCommand(NewCmdCreateNamespace(f, out)) + cmd.AddCommand(NewCmdCreateQuota(f, out)) cmd.AddCommand(NewCmdCreateSecret(f, out)) cmd.AddCommand(NewCmdCreateConfigMap(f, out)) cmd.AddCommand(NewCmdCreateServiceAccount(f, out)) diff --git a/pkg/kubectl/cmd/create_quota.go b/pkg/kubectl/cmd/create_quota.go new file mode 100644 index 00000000000..26ba236b44e --- /dev/null +++ b/pkg/kubectl/cmd/create_quota.go @@ -0,0 +1,87 @@ +/* +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" + + "github.com/spf13/cobra" + + "k8s.io/kubernetes/pkg/kubectl" + cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util" +) + +const ( + quotaLong = ` +Create a resourcequota with the specified name and hard limits` + + quotaExample = ` // Create a new resourcequota named my-quota + $ kubectl create quota my-quota --hard=cpu=1,memory=1G,pods=2,services=3,replicationcontrollers=2,resourcequotas=1,secrets=5,persistentvolumeclaims=10` +) + +// NewCmdCreateQuota is a macro command to create a new quota +func NewCmdCreateQuota(f *cmdutil.Factory, cmdOut io.Writer) *cobra.Command { + cmd := &cobra.Command{ + Use: "quota NAME [--hard=key1=value1,key2=value2] [--dry-run=bool]", + Aliases: []string{"q"}, + Short: "Create a quota with the specified name.", + Long: quotaLong, + Example: quotaExample, + Run: func(cmd *cobra.Command, args []string) { + err := CreateQuota(f, cmdOut, cmd, args) + cmdutil.CheckErr(err) + }, + } + + cmdutil.AddApplyAnnotationFlags(cmd) + cmdutil.AddValidateFlags(cmd) + cmdutil.AddGeneratorFlags(cmd, cmdutil.ResourceQuotaV1GeneratorName) + cmd.Flags().String("hard", "", "Specify multiple key/value pair to insert in resourcequota (i.e. --hard=cpu=1,memory=1G,pods=2,services=3,replicationcontrollers=2,resourcequotas=1,secrets=5,persistentvolumeclaims=10)") + cmd.MarkFlagRequired("hard") + return cmd +} + +// CreateQuota implements the behavior to run the create quota command +func CreateQuota(f *cmdutil.Factory, cmdOut io.Writer, cmd *cobra.Command, args []string) error { + name, err := NameFromCommandArgs(cmd, args) + if err != nil { + return err + } + requiredFlags := []string{"hard"} + for _, requiredFlag := range requiredFlags { + if value := cmdutil.GetFlagString(cmd, requiredFlag); len(value) == 0 { + return cmdutil.UsageError(cmd, "flag %s is required", requiredFlag) + } + } + var generator kubectl.StructuredGenerator + switch generatorName := cmdutil.GetFlagString(cmd, "generator"); generatorName { + case cmdutil.ResourceQuotaV1GeneratorName: + generator = &kubectl.ResourceQuotaGeneratorV1{ + Name: name, + Hard: cmdutil.GetFlagString(cmd, "hard"), + } + default: + return cmdutil.UsageError(cmd, fmt.Sprintf("Generator: %s not supported.", generatorName)) + } + return RunCreateSubcommand(f, cmd, cmdOut, &CreateSubcommandOptions{ + Name: name, + StructuredGenerator: generator, + DryRun: cmdutil.GetFlagBool(cmd, "dry-run"), + OutputFormat: cmdutil.GetFlagString(cmd, "output"), + }) +} diff --git a/pkg/kubectl/cmd/create_quota_test.go b/pkg/kubectl/cmd/create_quota_test.go new file mode 100644 index 00000000000..cbaf779e575 --- /dev/null +++ b/pkg/kubectl/cmd/create_quota_test.go @@ -0,0 +1,55 @@ +/* +Copyright 2014 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 ( + "bytes" + "net/http" + "testing" + + "k8s.io/kubernetes/pkg/api" + "k8s.io/kubernetes/pkg/client/unversioned/fake" +) + +func TestCreateQuota(t *testing.T) { + resourceQuotaObject := &api.ResourceQuota{} + resourceQuotaObject.Name = "my-quota" + f, tf, codec := NewAPIFactory() + tf.Printer = &testPrinter{} + tf.Client = &fake.RESTClient{ + Codec: codec, + Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { + switch p, m := req.URL.Path, req.Method; { + case p == "/namespaces/test/resourcequotas" && m == "POST": + return &http.Response{StatusCode: 201, Body: objBody(codec, resourceQuotaObject)}, nil + default: + t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) + return nil, nil + } + }), + } + tf.Namespace = "test" + buf := bytes.NewBuffer([]byte{}) + cmd := NewCmdCreateQuota(f, buf) + cmd.Flags().Set("hard", "cpu=1") + cmd.Flags().Set("output", "name") + cmd.Run(cmd, []string{resourceQuotaObject.Name}) + expectedOutput := "resourcequota/" + resourceQuotaObject.Name + "\n" + if buf.String() != expectedOutput { + t.Errorf("expected output: %s, but got: %s", expectedOutput, buf.String()) + } +} diff --git a/pkg/kubectl/cmd/util/factory.go b/pkg/kubectl/cmd/util/factory.go index 3bcf7bf54f4..f40335e308d 100644 --- a/pkg/kubectl/cmd/util/factory.go +++ b/pkg/kubectl/cmd/util/factory.go @@ -165,6 +165,7 @@ const ( JobV1Beta1GeneratorName = "job/v1beta1" JobV1GeneratorName = "job/v1" NamespaceV1GeneratorName = "namespace/v1" + ResourceQuotaV1GeneratorName = "resourcequotas/v1" SecretV1GeneratorName = "secret/v1" SecretForDockerRegistryV1GeneratorName = "secret-for-docker-registry/v1" SecretForTLSV1GeneratorName = "secret-for-tls/v1" @@ -192,6 +193,11 @@ func DefaultGenerators(cmdName string) map[string]kubectl.Generator { generators["namespace"] = map[string]kubectl.Generator{ NamespaceV1GeneratorName: kubectl.NamespaceGeneratorV1{}, } + + generators["quota"] = map[string]kubectl.Generator{ + ResourceQuotaV1GeneratorName: kubectl.ResourceQuotaGeneratorV1{}, + } + generators["secret"] = map[string]kubectl.Generator{ SecretV1GeneratorName: kubectl.SecretGeneratorV1{}, } diff --git a/pkg/kubectl/quota.go b/pkg/kubectl/quota.go new file mode 100644 index 00000000000..e6409905b52 --- /dev/null +++ b/pkg/kubectl/quota.go @@ -0,0 +1,113 @@ +/* +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" + + "k8s.io/kubernetes/pkg/api" + "k8s.io/kubernetes/pkg/api/resource" + "k8s.io/kubernetes/pkg/runtime" + "strings" +) + +// ResourceQuotaGeneratorV1 supports stable generation of a namespace +type ResourceQuotaGeneratorV1 struct { + Name string + Hard string +} + +// ParamNames returns the set of supported input parameters when using the parameter injection generator pattern +func (g ResourceQuotaGeneratorV1) ParamNames() []GeneratorParam { + return []GeneratorParam{ + {"name", true}, + {"hard", true}, + } +} + +// Ensure it supports the generator pattern that uses parameter injection +var _ Generator = &ResourceQuotaGeneratorV1{} + +// Ensure it supports the generator pattern that uses parameters specified during construction +var _ StructuredGenerator = &ResourceQuotaGeneratorV1{} + +func (g ResourceQuotaGeneratorV1) Generate(genericParams map[string]interface{}) (runtime.Object, error) { + err := ValidateParams(g.ParamNames(), genericParams) + if err != nil { + return nil, err + } + + 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 + } + + delegate := &ResourceQuotaGeneratorV1{} + delegate.Name = params["name"] + delegate.Hard = params["hard"] + return delegate.StructuredGenerate() +} + +// StructuredGenerate outputs a ResourceQuota object using the configured fields +func (g *ResourceQuotaGeneratorV1) StructuredGenerate() (runtime.Object, error) { + if err := g.validate(); err != nil { + return nil, err + } + + resourceQuotaSpec, err := generateResourceQuotaSpecList(g.Hard) + if err != nil { + return nil, err + } + + resourceQuota := &api.ResourceQuota{} + resourceQuota.Name = g.Name + resourceQuota.Spec.Hard = resourceQuotaSpec + return resourceQuota, nil +} + +func generateResourceQuotaSpecList(hard string) (resourceList api.ResourceList, err error) { + + defer func() { + if p := recover(); p != nil { + resourceList = nil + err = fmt.Errorf("Invalid input %v", p) + } + }() + + resourceList = make(api.ResourceList) + for _, keyValue := range strings.Split(hard, ",") { + items := strings.Split(keyValue, "=") + if len(items) != 2 { + return nil, fmt.Errorf("invalid input %v, expected key=value", keyValue) + } + + resourceList[api.ResourceName(items[0])] = resource.MustParse(items[1]) + } + return +} + +// validate validates required fields are set to support structured generation +func (r *ResourceQuotaGeneratorV1) validate() error { + if len(r.Name) == 0 { + return fmt.Errorf("name must be specified") + } + return nil +} diff --git a/pkg/kubectl/quota_test.go b/pkg/kubectl/quota_test.go new file mode 100644 index 00000000000..07075f3bc44 --- /dev/null +++ b/pkg/kubectl/quota_test.go @@ -0,0 +1,81 @@ +/* +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 ( + "reflect" + "testing" + + "k8s.io/kubernetes/pkg/api" +) + +func TestQuotaGenerate(t *testing.T) { + hard := "cpu=10,memory=5G,pods=10,services=7" + resourceQuotaSpecList, err := generateResourceQuotaSpecList(hard) + if err != nil { + t.Errorf("unexpected error: %v", err) + } + + tests := map[string]struct { + params map[string]interface{} + expected *api.ResourceQuota + expectErr bool + }{ + "test-valid-use": { + params: map[string]interface{}{ + "name": "foo", + "hard": hard, + }, + expected: &api.ResourceQuota{ + ObjectMeta: api.ObjectMeta{ + Name: "foo", + }, + Spec: api.ResourceQuotaSpec{Hard: resourceQuotaSpecList}, + }, + expectErr: false, + }, + "test-missing-required-param": { + params: map[string]interface{}{ + "name": "foo", + }, + expectErr: true, + }, + } + + generator := ResourceQuotaGeneratorV1{} + for _, test := range tests { + obj, err := generator.Generate(test.params) + if !test.expectErr && err != nil { + t.Errorf("unexpected error: %v", err) + } + if test.expectErr && err != nil { + continue + } + if !reflect.DeepEqual(obj.(*api.ResourceQuota), test.expected) { + t.Errorf("\nexpected:\n%#v\nsaw:\n%#v", test.expected, obj.(*api.ResourceQuota)) + } + } +} + +func TestGenerateResourceQuotaSpecList(t *testing.T) { + hardInvalidValue := "cpu=23foo,memory=5G,pods=10bar,services=7" + + resourceList, err := generateResourceQuotaSpecList(hardInvalidValue) + if err != nil && resourceList != nil { + t.Errorf("\nexpected:\n%#v\nsaw:\n%#v", nil, resourceList) + } +}