mirror of https://github.com/k3s-io/k3s
128 lines
4.2 KiB
Go
128 lines
4.2 KiB
Go
/*
|
|
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 (
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
|
|
"github.com/spf13/cobra"
|
|
"k8s.io/kubernetes/pkg/api"
|
|
"k8s.io/kubernetes/pkg/kubectl"
|
|
cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
|
|
)
|
|
|
|
const (
|
|
run_long = `Create and run a particular image, possibly replicated.
|
|
Creates a replication controller to manage the created container(s).`
|
|
run_example = `// Starts a single instance of nginx.
|
|
$ kubectl run nginx --image=nginx
|
|
|
|
// Starts a replicated instance of nginx.
|
|
$ kubectl run nginx --image=nginx --replicas=5
|
|
|
|
// Dry run. Print the corresponding API objects without creating them.
|
|
$ kubectl run nginx --image=nginx --dry-run
|
|
|
|
// Start a single instance of nginx, but overload the spec of the replication controller with a partial set of values parsed from JSON.
|
|
$ kubectl run nginx --image=nginx --overrides='{ "apiVersion": "v1", "spec": { ... } }'`
|
|
)
|
|
|
|
func NewCmdRun(f *cmdutil.Factory, out io.Writer) *cobra.Command {
|
|
cmd := &cobra.Command{
|
|
Use: "run NAME --image=image [--port=port] [--replicas=replicas] [--dry-run=bool] [--overrides=inline-json]",
|
|
// run-container is deprecated
|
|
Aliases: []string{"run-container"},
|
|
Short: "Run a particular image on the cluster.",
|
|
Long: run_long,
|
|
Example: run_example,
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
err := Run(f, out, cmd, args)
|
|
cmdutil.CheckErr(err)
|
|
},
|
|
}
|
|
cmdutil.AddPrinterFlags(cmd)
|
|
cmd.Flags().String("generator", "run/v1", "The name of the API generator to use. Default is 'run-controller/v1'.")
|
|
cmd.Flags().String("image", "", "The image for the container to run.")
|
|
cmd.MarkFlagRequired("image")
|
|
cmd.Flags().IntP("replicas", "r", 1, "Number of replicas to create for this container. Default is 1.")
|
|
cmd.Flags().Bool("dry-run", false, "If true, only print the object that would be sent, without sending it.")
|
|
cmd.Flags().String("overrides", "", "An inline JSON override for the generated object. If this is non-empty, it is used to override the generated object. Requires that the object supply a valid apiVersion field.")
|
|
cmd.Flags().Int("port", -1, "The port that this container exposes.")
|
|
cmd.Flags().Int("hostport", -1, "The host port mapping for the container port. To demonstrate a single-machine container.")
|
|
cmd.Flags().StringP("labels", "l", "", "Labels to apply to the pod(s).")
|
|
return cmd
|
|
}
|
|
|
|
func Run(f *cmdutil.Factory, out io.Writer, cmd *cobra.Command, args []string) error {
|
|
if len(os.Args) > 1 && os.Args[1] == "run-container" {
|
|
printDeprecationWarning("run", "run-container")
|
|
}
|
|
|
|
if len(args) != 1 {
|
|
return cmdutil.UsageError(cmd, "NAME is required for run")
|
|
}
|
|
|
|
namespace, _, err := f.DefaultNamespace()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
client, err := f.Client()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
generatorName := cmdutil.GetFlagString(cmd, "generator")
|
|
generator, found := f.Generator(generatorName)
|
|
if !found {
|
|
return cmdutil.UsageError(cmd, fmt.Sprintf("Generator: %s not found.", generator))
|
|
}
|
|
names := generator.ParamNames()
|
|
params := kubectl.MakeParams(cmd, names)
|
|
params["name"] = args[0]
|
|
|
|
err = kubectl.ValidateParams(names, params)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
controller, err := generator.Generate(params)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
inline := cmdutil.GetFlagString(cmd, "overrides")
|
|
if len(inline) > 0 {
|
|
controller, err = cmdutil.Merge(controller, inline, "ReplicationController")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// TODO: extract this flag to a central location, when such a location exists.
|
|
if !cmdutil.GetFlagBool(cmd, "dry-run") {
|
|
controller, err = client.ReplicationControllers(namespace).Create(controller.(*api.ReplicationController))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return f.PrintObject(cmd, controller, out)
|
|
}
|