run.go 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720
  1. /*
  2. Copyright 2014 The Kubernetes Authors.
  3. Licensed under the Apache License, Version 2.0 (the "License");
  4. you may not use this file except in compliance with the License.
  5. You may obtain a copy of the License at
  6. http://www.apache.org/licenses/LICENSE-2.0
  7. Unless required by applicable law or agreed to in writing, software
  8. distributed under the License is distributed on an "AS IS" BASIS,
  9. WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  10. See the License for the specific language governing permissions and
  11. limitations under the License.
  12. */
  13. package run
  14. import (
  15. "context"
  16. "fmt"
  17. "time"
  18. "github.com/docker/distribution/reference"
  19. "github.com/spf13/cobra"
  20. "k8s.io/klog"
  21. corev1 "k8s.io/api/core/v1"
  22. "k8s.io/apimachinery/pkg/api/errors"
  23. "k8s.io/apimachinery/pkg/api/meta"
  24. metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
  25. "k8s.io/apimachinery/pkg/fields"
  26. "k8s.io/apimachinery/pkg/runtime"
  27. utilerrors "k8s.io/apimachinery/pkg/util/errors"
  28. "k8s.io/apimachinery/pkg/watch"
  29. "k8s.io/cli-runtime/pkg/genericclioptions"
  30. "k8s.io/cli-runtime/pkg/resource"
  31. "k8s.io/client-go/dynamic"
  32. "k8s.io/client-go/kubernetes"
  33. corev1client "k8s.io/client-go/kubernetes/typed/core/v1"
  34. "k8s.io/client-go/tools/cache"
  35. watchtools "k8s.io/client-go/tools/watch"
  36. "k8s.io/kubernetes/pkg/kubectl"
  37. "k8s.io/kubernetes/pkg/kubectl/cmd/attach"
  38. "k8s.io/kubernetes/pkg/kubectl/cmd/delete"
  39. "k8s.io/kubernetes/pkg/kubectl/cmd/exec"
  40. "k8s.io/kubernetes/pkg/kubectl/cmd/logs"
  41. cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
  42. "k8s.io/kubernetes/pkg/kubectl/generate"
  43. generateversioned "k8s.io/kubernetes/pkg/kubectl/generate/versioned"
  44. "k8s.io/kubernetes/pkg/kubectl/polymorphichelpers"
  45. "k8s.io/kubernetes/pkg/kubectl/scheme"
  46. "k8s.io/kubernetes/pkg/kubectl/util/i18n"
  47. "k8s.io/kubernetes/pkg/kubectl/util/interrupt"
  48. "k8s.io/kubernetes/pkg/kubectl/util/templates"
  49. uexec "k8s.io/utils/exec"
  50. )
  51. var (
  52. runLong = templates.LongDesc(i18n.T(`
  53. Create and run a particular image, possibly replicated.
  54. Creates a deployment or job to manage the created container(s).`))
  55. runExample = templates.Examples(i18n.T(`
  56. # Start a single instance of nginx.
  57. kubectl run nginx --image=nginx
  58. # Start a single instance of hazelcast and let the container expose port 5701 .
  59. kubectl run hazelcast --image=hazelcast --port=5701
  60. # Start a single instance of hazelcast and set environment variables "DNS_DOMAIN=cluster" and "POD_NAMESPACE=default" in the container.
  61. kubectl run hazelcast --image=hazelcast --env="DNS_DOMAIN=cluster" --env="POD_NAMESPACE=default"
  62. # Start a single instance of hazelcast and set labels "app=hazelcast" and "env=prod" in the container.
  63. kubectl run hazelcast --image=hazelcast --labels="app=hazelcast,env=prod"
  64. # Start a replicated instance of nginx.
  65. kubectl run nginx --image=nginx --replicas=5
  66. # Dry run. Print the corresponding API objects without creating them.
  67. kubectl run nginx --image=nginx --dry-run
  68. # Start a single instance of nginx, but overload the spec of the deployment with a partial set of values parsed from JSON.
  69. kubectl run nginx --image=nginx --overrides='{ "apiVersion": "v1", "spec": { ... } }'
  70. # Start a pod of busybox and keep it in the foreground, don't restart it if it exits.
  71. kubectl run -i -t busybox --image=busybox --restart=Never
  72. # Start the nginx container using the default command, but use custom arguments (arg1 .. argN) for that command.
  73. kubectl run nginx --image=nginx -- <arg1> <arg2> ... <argN>
  74. # Start the nginx container using a different command and custom arguments.
  75. kubectl run nginx --image=nginx --command -- <cmd> <arg1> ... <argN>
  76. # Start the perl container to compute π to 2000 places and print it out.
  77. kubectl run pi --image=perl --restart=OnFailure -- perl -Mbignum=bpi -wle 'print bpi(2000)'
  78. # Start the cron job to compute π to 2000 places and print it out every 5 minutes.
  79. kubectl run pi --schedule="0/5 * * * ?" --image=perl --restart=OnFailure -- perl -Mbignum=bpi -wle 'print bpi(2000)'`))
  80. )
  81. const (
  82. defaultPodAttachTimeout = 60 * time.Second
  83. )
  84. var metadataAccessor = meta.NewAccessor()
  85. type RunObject struct {
  86. Object runtime.Object
  87. Mapping *meta.RESTMapping
  88. }
  89. type RunOptions struct {
  90. PrintFlags *genericclioptions.PrintFlags
  91. RecordFlags *genericclioptions.RecordFlags
  92. DeleteFlags *delete.DeleteFlags
  93. DeleteOptions *delete.DeleteOptions
  94. DryRun bool
  95. PrintObj func(runtime.Object) error
  96. Recorder genericclioptions.Recorder
  97. DynamicClient dynamic.Interface
  98. ArgsLenAtDash int
  99. Attach bool
  100. Expose bool
  101. Generator string
  102. Image string
  103. Interactive bool
  104. LeaveStdinOpen bool
  105. Port string
  106. Quiet bool
  107. Schedule string
  108. TTY bool
  109. genericclioptions.IOStreams
  110. }
  111. func NewRunOptions(streams genericclioptions.IOStreams) *RunOptions {
  112. return &RunOptions{
  113. PrintFlags: genericclioptions.NewPrintFlags("created").WithTypeSetter(scheme.Scheme),
  114. DeleteFlags: delete.NewDeleteFlags("to use to replace the resource."),
  115. RecordFlags: genericclioptions.NewRecordFlags(),
  116. Recorder: genericclioptions.NoopRecorder{},
  117. IOStreams: streams,
  118. }
  119. }
  120. func NewCmdRun(f cmdutil.Factory, streams genericclioptions.IOStreams) *cobra.Command {
  121. o := NewRunOptions(streams)
  122. cmd := &cobra.Command{
  123. Use: "run NAME --image=image [--env=\"key=value\"] [--port=port] [--replicas=replicas] [--dry-run=bool] [--overrides=inline-json] [--command] -- [COMMAND] [args...]",
  124. DisableFlagsInUseLine: true,
  125. Short: i18n.T("Run a particular image on the cluster"),
  126. Long: runLong,
  127. Example: runExample,
  128. Run: func(cmd *cobra.Command, args []string) {
  129. cmdutil.CheckErr(o.Complete(f, cmd))
  130. cmdutil.CheckErr(o.Run(f, cmd, args))
  131. },
  132. }
  133. o.DeleteFlags.AddFlags(cmd)
  134. o.PrintFlags.AddFlags(cmd)
  135. o.RecordFlags.AddFlags(cmd)
  136. addRunFlags(cmd, o)
  137. cmdutil.AddApplyAnnotationFlags(cmd)
  138. cmdutil.AddPodRunningTimeoutFlag(cmd, defaultPodAttachTimeout)
  139. return cmd
  140. }
  141. func addRunFlags(cmd *cobra.Command, opt *RunOptions) {
  142. cmdutil.AddDryRunFlag(cmd)
  143. cmd.Flags().StringVar(&opt.Generator, "generator", opt.Generator, i18n.T("The name of the API generator to use, see http://kubernetes.io/docs/user-guide/kubectl-conventions/#generators for a list."))
  144. cmd.Flags().StringVar(&opt.Image, "image", opt.Image, i18n.T("The image for the container to run."))
  145. cmd.MarkFlagRequired("image")
  146. cmd.Flags().String("image-pull-policy", "", i18n.T("The image pull policy for the container. If left empty, this value will not be specified by the client and defaulted by the server"))
  147. cmd.Flags().IntP("replicas", "r", 1, "Number of replicas to create for this container. Default is 1.")
  148. cmd.Flags().Bool("rm", false, "If true, delete resources created in this command for attached containers.")
  149. cmd.Flags().String("overrides", "", i18n.T("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."))
  150. cmd.Flags().StringArray("env", []string{}, "Environment variables to set in the container")
  151. cmd.Flags().String("serviceaccount", "", "Service account to set in the pod spec")
  152. cmd.Flags().StringVar(&opt.Port, "port", opt.Port, i18n.T("The port that this container exposes. If --expose is true, this is also the port used by the service that is created."))
  153. cmd.Flags().Int("hostport", -1, "The host port mapping for the container port. To demonstrate a single-machine container.")
  154. cmd.Flags().StringP("labels", "l", "", "Comma separated labels to apply to the pod(s). Will override previous values.")
  155. cmd.Flags().BoolVarP(&opt.Interactive, "stdin", "i", opt.Interactive, "Keep stdin open on the container(s) in the pod, even if nothing is attached.")
  156. cmd.Flags().BoolVarP(&opt.TTY, "tty", "t", opt.TTY, "Allocated a TTY for each container in the pod.")
  157. cmd.Flags().BoolVar(&opt.Attach, "attach", opt.Attach, "If true, wait for the Pod to start running, and then attach to the Pod as if 'kubectl attach ...' were called. Default false, unless '-i/--stdin' is set, in which case the default is true. With '--restart=Never' the exit code of the container process is returned.")
  158. cmd.Flags().BoolVar(&opt.LeaveStdinOpen, "leave-stdin-open", opt.LeaveStdinOpen, "If the pod is started in interactive mode or with stdin, leave stdin open after the first attach completes. By default, stdin will be closed after the first attach completes.")
  159. cmd.Flags().String("restart", "Always", i18n.T("The restart policy for this Pod. Legal values [Always, OnFailure, Never]. If set to 'Always' a deployment is created, if set to 'OnFailure' a job is created, if set to 'Never', a regular pod is created. For the latter two --replicas must be 1. Default 'Always', for CronJobs `Never`."))
  160. cmd.Flags().Bool("command", false, "If true and extra arguments are present, use them as the 'command' field in the container, rather than the 'args' field which is the default.")
  161. cmd.Flags().String("requests", "", i18n.T("The resource requirement requests for this container. For example, 'cpu=100m,memory=256Mi'. Note that server side components may assign requests depending on the server configuration, such as limit ranges."))
  162. cmd.Flags().String("limits", "", i18n.T("The resource requirement limits for this container. For example, 'cpu=200m,memory=512Mi'. Note that server side components may assign limits depending on the server configuration, such as limit ranges."))
  163. cmd.Flags().BoolVar(&opt.Expose, "expose", opt.Expose, "If true, a public, external service is created for the container(s) which are run")
  164. cmd.Flags().String("service-generator", "service/v2", i18n.T("The name of the generator to use for creating a service. Only used if --expose is true"))
  165. cmd.Flags().String("service-overrides", "", i18n.T("An inline JSON override for the generated service object. If this is non-empty, it is used to override the generated object. Requires that the object supply a valid apiVersion field. Only used if --expose is true."))
  166. cmd.Flags().BoolVar(&opt.Quiet, "quiet", opt.Quiet, "If true, suppress prompt messages.")
  167. cmd.Flags().StringVar(&opt.Schedule, "schedule", opt.Schedule, i18n.T("A schedule in the Cron format the job should be run with."))
  168. }
  169. func (o *RunOptions) Complete(f cmdutil.Factory, cmd *cobra.Command) error {
  170. var err error
  171. o.RecordFlags.Complete(cmd)
  172. o.Recorder, err = o.RecordFlags.ToRecorder()
  173. if err != nil {
  174. return err
  175. }
  176. o.DynamicClient, err = f.DynamicClient()
  177. if err != nil {
  178. return err
  179. }
  180. o.ArgsLenAtDash = cmd.ArgsLenAtDash()
  181. o.DryRun = cmdutil.GetFlagBool(cmd, "dry-run")
  182. attachFlag := cmd.Flags().Lookup("attach")
  183. if !attachFlag.Changed && o.Interactive {
  184. o.Attach = true
  185. }
  186. if o.DryRun {
  187. o.PrintFlags.Complete("%s (dry run)")
  188. }
  189. printer, err := o.PrintFlags.ToPrinter()
  190. if err != nil {
  191. return err
  192. }
  193. o.PrintObj = func(obj runtime.Object) error {
  194. return printer.PrintObj(obj, o.Out)
  195. }
  196. deleteOpts := o.DeleteFlags.ToOptions(o.DynamicClient, o.IOStreams)
  197. deleteOpts.IgnoreNotFound = true
  198. deleteOpts.WaitForDeletion = false
  199. deleteOpts.GracePeriod = -1
  200. deleteOpts.Quiet = o.Quiet
  201. o.DeleteOptions = deleteOpts
  202. return nil
  203. }
  204. func (o *RunOptions) Run(f cmdutil.Factory, cmd *cobra.Command, args []string) error {
  205. // Let kubectl run follow rules for `--`, see #13004 issue
  206. if len(args) == 0 || o.ArgsLenAtDash == 0 {
  207. return cmdutil.UsageErrorf(cmd, "NAME is required for run")
  208. }
  209. timeout, err := cmdutil.GetPodRunningTimeoutFlag(cmd)
  210. if err != nil {
  211. return cmdutil.UsageErrorf(cmd, "%v", err)
  212. }
  213. // validate image name
  214. imageName := o.Image
  215. if imageName == "" {
  216. return fmt.Errorf("--image is required")
  217. }
  218. validImageRef := reference.ReferenceRegexp.MatchString(imageName)
  219. if !validImageRef {
  220. return fmt.Errorf("Invalid image name %q: %v", imageName, reference.ErrReferenceInvalidFormat)
  221. }
  222. if o.TTY && !o.Interactive {
  223. return cmdutil.UsageErrorf(cmd, "-i/--stdin is required for containers with -t/--tty=true")
  224. }
  225. replicas := cmdutil.GetFlagInt(cmd, "replicas")
  226. if o.Interactive && replicas != 1 {
  227. return cmdutil.UsageErrorf(cmd, "-i/--stdin requires that replicas is 1, found %d", replicas)
  228. }
  229. if o.Expose && len(o.Port) == 0 {
  230. return cmdutil.UsageErrorf(cmd, "--port must be set when exposing a service")
  231. }
  232. namespace, _, err := f.ToRawKubeConfigLoader().Namespace()
  233. if err != nil {
  234. return err
  235. }
  236. restartPolicy, err := getRestartPolicy(cmd, o.Interactive)
  237. if err != nil {
  238. return err
  239. }
  240. if restartPolicy != corev1.RestartPolicyAlways && replicas != 1 {
  241. return cmdutil.UsageErrorf(cmd, "--restart=%s requires that --replicas=1, found %d", restartPolicy, replicas)
  242. }
  243. remove := cmdutil.GetFlagBool(cmd, "rm")
  244. if !o.Attach && remove {
  245. return cmdutil.UsageErrorf(cmd, "--rm should only be used for attached containers")
  246. }
  247. if o.Attach && o.DryRun {
  248. return cmdutil.UsageErrorf(cmd, "--dry-run can't be used with attached containers options (--attach, --stdin, or --tty)")
  249. }
  250. if err := verifyImagePullPolicy(cmd); err != nil {
  251. return err
  252. }
  253. clientset, err := f.KubernetesClientSet()
  254. if err != nil {
  255. return err
  256. }
  257. generatorName := o.Generator
  258. if len(o.Schedule) != 0 && len(generatorName) == 0 {
  259. generatorName = generateversioned.CronJobV1Beta1GeneratorName
  260. }
  261. if len(generatorName) == 0 {
  262. switch restartPolicy {
  263. case corev1.RestartPolicyAlways:
  264. generatorName = generateversioned.DeploymentAppsV1GeneratorName
  265. case corev1.RestartPolicyOnFailure:
  266. generatorName = generateversioned.JobV1GeneratorName
  267. case corev1.RestartPolicyNever:
  268. generatorName = generateversioned.RunPodV1GeneratorName
  269. }
  270. // Falling back because the generator was not provided and the default one could be unavailable.
  271. generatorNameTemp, err := generateversioned.FallbackGeneratorNameIfNecessary(generatorName, clientset.Discovery(), o.ErrOut)
  272. if err != nil {
  273. return err
  274. }
  275. if generatorNameTemp != generatorName {
  276. cmdutil.Warning(o.ErrOut, generatorName, generatorNameTemp)
  277. } else {
  278. generatorName = generatorNameTemp
  279. }
  280. }
  281. // start deprecating all generators except for 'run-pod/v1' which will be
  282. // the only supported on a route to simple kubectl run which should mimic
  283. // docker run
  284. if generatorName != generateversioned.RunPodV1GeneratorName {
  285. fmt.Fprintf(o.ErrOut, "kubectl run --generator=%s is DEPRECATED and will be removed in a future version. Use kubectl run --generator=%s or kubectl create instead.\n", generatorName, generateversioned.RunPodV1GeneratorName)
  286. }
  287. generators := generateversioned.GeneratorFn("run")
  288. generator, found := generators[generatorName]
  289. if !found {
  290. return cmdutil.UsageErrorf(cmd, "generator %q not found", generatorName)
  291. }
  292. names := generator.ParamNames()
  293. params := generate.MakeParams(cmd, names)
  294. params["name"] = args[0]
  295. if len(args) > 1 {
  296. params["args"] = args[1:]
  297. }
  298. params["env"] = cmdutil.GetFlagStringArray(cmd, "env")
  299. var createdObjects = []*RunObject{}
  300. runObject, err := o.createGeneratedObject(f, cmd, generator, names, params, cmdutil.GetFlagString(cmd, "overrides"), namespace)
  301. if err != nil {
  302. return err
  303. }
  304. createdObjects = append(createdObjects, runObject)
  305. allErrs := []error{}
  306. if o.Expose {
  307. serviceGenerator := cmdutil.GetFlagString(cmd, "service-generator")
  308. if len(serviceGenerator) == 0 {
  309. return cmdutil.UsageErrorf(cmd, "No service generator specified")
  310. }
  311. serviceRunObject, err := o.generateService(f, cmd, serviceGenerator, params, namespace)
  312. if err != nil {
  313. allErrs = append(allErrs, err)
  314. } else {
  315. createdObjects = append(createdObjects, serviceRunObject)
  316. }
  317. }
  318. if o.Attach {
  319. if remove {
  320. defer o.removeCreatedObjects(f, createdObjects)
  321. }
  322. opts := &attach.AttachOptions{
  323. StreamOptions: exec.StreamOptions{
  324. IOStreams: o.IOStreams,
  325. Stdin: o.Interactive,
  326. TTY: o.TTY,
  327. Quiet: o.Quiet,
  328. },
  329. GetPodTimeout: timeout,
  330. CommandName: cmd.Parent().CommandPath() + " attach",
  331. Attach: &attach.DefaultRemoteAttach{},
  332. }
  333. config, err := f.ToRESTConfig()
  334. if err != nil {
  335. return err
  336. }
  337. opts.Config = config
  338. opts.AttachFunc = attach.DefaultAttachFunc
  339. clientset, err := kubernetes.NewForConfig(config)
  340. if err != nil {
  341. return err
  342. }
  343. attachablePod, err := polymorphichelpers.AttachablePodForObjectFn(f, runObject.Object, opts.GetPodTimeout)
  344. if err != nil {
  345. return err
  346. }
  347. err = handleAttachPod(f, clientset.CoreV1(), attachablePod.Namespace, attachablePod.Name, opts)
  348. if err != nil {
  349. return err
  350. }
  351. var pod *corev1.Pod
  352. leaveStdinOpen := o.LeaveStdinOpen
  353. waitForExitCode := !leaveStdinOpen && restartPolicy == corev1.RestartPolicyNever
  354. if waitForExitCode {
  355. pod, err = waitForPod(clientset.CoreV1(), attachablePod.Namespace, attachablePod.Name, kubectl.PodCompleted)
  356. if err != nil {
  357. return err
  358. }
  359. }
  360. // after removal is done, return successfully if we are not interested in the exit code
  361. if !waitForExitCode {
  362. return nil
  363. }
  364. switch pod.Status.Phase {
  365. case corev1.PodSucceeded:
  366. return nil
  367. case corev1.PodFailed:
  368. unknownRcErr := fmt.Errorf("pod %s/%s failed with unknown exit code", pod.Namespace, pod.Name)
  369. if len(pod.Status.ContainerStatuses) == 0 || pod.Status.ContainerStatuses[0].State.Terminated == nil {
  370. return unknownRcErr
  371. }
  372. // assume here that we have at most one status because kubectl-run only creates one container per pod
  373. rc := pod.Status.ContainerStatuses[0].State.Terminated.ExitCode
  374. if rc == 0 {
  375. return unknownRcErr
  376. }
  377. return uexec.CodeExitError{
  378. Err: fmt.Errorf("pod %s/%s terminated (%s)\n%s", pod.Namespace, pod.Name, pod.Status.ContainerStatuses[0].State.Terminated.Reason, pod.Status.ContainerStatuses[0].State.Terminated.Message),
  379. Code: int(rc),
  380. }
  381. default:
  382. return fmt.Errorf("pod %s/%s left in phase %s", pod.Namespace, pod.Name, pod.Status.Phase)
  383. }
  384. }
  385. if runObject != nil {
  386. if err := o.PrintObj(runObject.Object); err != nil {
  387. return err
  388. }
  389. }
  390. return utilerrors.NewAggregate(allErrs)
  391. }
  392. func (o *RunOptions) removeCreatedObjects(f cmdutil.Factory, createdObjects []*RunObject) error {
  393. for _, obj := range createdObjects {
  394. namespace, err := metadataAccessor.Namespace(obj.Object)
  395. if err != nil {
  396. return err
  397. }
  398. var name string
  399. name, err = metadataAccessor.Name(obj.Object)
  400. if err != nil {
  401. return err
  402. }
  403. r := f.NewBuilder().
  404. WithScheme(scheme.Scheme, scheme.Scheme.PrioritizedVersionsAllGroups()...).
  405. ContinueOnError().
  406. NamespaceParam(namespace).DefaultNamespace().
  407. ResourceNames(obj.Mapping.Resource.Resource+"."+obj.Mapping.Resource.Group, name).
  408. Flatten().
  409. Do()
  410. if err := o.DeleteOptions.DeleteResult(r); err != nil {
  411. return err
  412. }
  413. }
  414. return nil
  415. }
  416. // waitForPod watches the given pod until the exitCondition is true
  417. func waitForPod(podClient corev1client.PodsGetter, ns, name string, exitCondition watchtools.ConditionFunc) (*corev1.Pod, error) {
  418. // TODO: expose the timeout
  419. ctx, cancel := watchtools.ContextWithOptionalTimeout(context.Background(), 0*time.Second)
  420. defer cancel()
  421. preconditionFunc := func(store cache.Store) (bool, error) {
  422. _, exists, err := store.Get(&metav1.ObjectMeta{Namespace: ns, Name: name})
  423. if err != nil {
  424. return true, err
  425. }
  426. if !exists {
  427. // We need to make sure we see the object in the cache before we start waiting for events
  428. // or we would be waiting for the timeout if such object didn't exist.
  429. // (e.g. it was deleted before we started informers so they wouldn't even see the delete event)
  430. return true, errors.NewNotFound(corev1.Resource("pods"), name)
  431. }
  432. return false, nil
  433. }
  434. fieldSelector := fields.OneTermEqualSelector("metadata.name", name).String()
  435. lw := &cache.ListWatch{
  436. ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
  437. options.FieldSelector = fieldSelector
  438. return podClient.Pods(ns).List(options)
  439. },
  440. WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
  441. options.FieldSelector = fieldSelector
  442. return podClient.Pods(ns).Watch(options)
  443. },
  444. }
  445. intr := interrupt.New(nil, cancel)
  446. var result *corev1.Pod
  447. err := intr.Run(func() error {
  448. ev, err := watchtools.UntilWithSync(ctx, lw, &corev1.Pod{}, preconditionFunc, func(ev watch.Event) (bool, error) {
  449. return exitCondition(ev)
  450. })
  451. if ev != nil {
  452. result = ev.Object.(*corev1.Pod)
  453. }
  454. return err
  455. })
  456. return result, err
  457. }
  458. func handleAttachPod(f cmdutil.Factory, podClient corev1client.PodsGetter, ns, name string, opts *attach.AttachOptions) error {
  459. pod, err := waitForPod(podClient, ns, name, kubectl.PodRunningAndReady)
  460. if err != nil && err != kubectl.ErrPodCompleted {
  461. return err
  462. }
  463. if pod.Status.Phase == corev1.PodSucceeded || pod.Status.Phase == corev1.PodFailed {
  464. return logOpts(f, pod, opts)
  465. }
  466. opts.Pod = pod
  467. opts.PodName = name
  468. opts.Namespace = ns
  469. if opts.AttachFunc == nil {
  470. opts.AttachFunc = attach.DefaultAttachFunc
  471. }
  472. if err := opts.Run(); err != nil {
  473. fmt.Fprintf(opts.ErrOut, "Error attaching, falling back to logs: %v\n", err)
  474. return logOpts(f, pod, opts)
  475. }
  476. return nil
  477. }
  478. // logOpts logs output from opts to the pods log.
  479. func logOpts(restClientGetter genericclioptions.RESTClientGetter, pod *corev1.Pod, opts *attach.AttachOptions) error {
  480. ctrName, err := opts.GetContainerName(pod)
  481. if err != nil {
  482. return err
  483. }
  484. requests, err := polymorphichelpers.LogsForObjectFn(restClientGetter, pod, &corev1.PodLogOptions{Container: ctrName}, opts.GetPodTimeout, false)
  485. if err != nil {
  486. return err
  487. }
  488. for _, request := range requests {
  489. if err := logs.DefaultConsumeRequest(request, opts.Out); err != nil {
  490. return err
  491. }
  492. }
  493. return nil
  494. }
  495. func getRestartPolicy(cmd *cobra.Command, interactive bool) (corev1.RestartPolicy, error) {
  496. restart := cmdutil.GetFlagString(cmd, "restart")
  497. if len(restart) == 0 {
  498. if interactive {
  499. return corev1.RestartPolicyOnFailure, nil
  500. }
  501. return corev1.RestartPolicyAlways, nil
  502. }
  503. switch corev1.RestartPolicy(restart) {
  504. case corev1.RestartPolicyAlways:
  505. return corev1.RestartPolicyAlways, nil
  506. case corev1.RestartPolicyOnFailure:
  507. return corev1.RestartPolicyOnFailure, nil
  508. case corev1.RestartPolicyNever:
  509. return corev1.RestartPolicyNever, nil
  510. }
  511. return "", cmdutil.UsageErrorf(cmd, "invalid restart policy: %s", restart)
  512. }
  513. func verifyImagePullPolicy(cmd *cobra.Command) error {
  514. pullPolicy := cmdutil.GetFlagString(cmd, "image-pull-policy")
  515. switch corev1.PullPolicy(pullPolicy) {
  516. case corev1.PullAlways, corev1.PullIfNotPresent, corev1.PullNever:
  517. return nil
  518. case "":
  519. return nil
  520. }
  521. return cmdutil.UsageErrorf(cmd, "invalid image pull policy: %s", pullPolicy)
  522. }
  523. func (o *RunOptions) generateService(f cmdutil.Factory, cmd *cobra.Command, serviceGenerator string, paramsIn map[string]interface{}, namespace string) (*RunObject, error) {
  524. generators := generateversioned.GeneratorFn("expose")
  525. generator, found := generators[serviceGenerator]
  526. if !found {
  527. return nil, fmt.Errorf("missing service generator: %s", serviceGenerator)
  528. }
  529. names := generator.ParamNames()
  530. params := map[string]interface{}{}
  531. for key, value := range paramsIn {
  532. _, isString := value.(string)
  533. if isString {
  534. params[key] = value
  535. }
  536. }
  537. name, found := params["name"]
  538. if !found || len(name.(string)) == 0 {
  539. return nil, fmt.Errorf("name is a required parameter")
  540. }
  541. selector, found := params["labels"]
  542. if !found || len(selector.(string)) == 0 {
  543. selector = fmt.Sprintf("run=%s", name.(string))
  544. }
  545. params["selector"] = selector
  546. if defaultName, found := params["default-name"]; !found || len(defaultName.(string)) == 0 {
  547. params["default-name"] = name
  548. }
  549. runObject, err := o.createGeneratedObject(f, cmd, generator, names, params, cmdutil.GetFlagString(cmd, "service-overrides"), namespace)
  550. if err != nil {
  551. return nil, err
  552. }
  553. if err := o.PrintObj(runObject.Object); err != nil {
  554. return nil, err
  555. }
  556. // separate yaml objects
  557. if o.PrintFlags.OutputFormat != nil && *o.PrintFlags.OutputFormat == "yaml" {
  558. fmt.Fprintln(o.Out, "---")
  559. }
  560. return runObject, nil
  561. }
  562. func (o *RunOptions) createGeneratedObject(f cmdutil.Factory, cmd *cobra.Command, generator generate.Generator, names []generate.GeneratorParam, params map[string]interface{}, overrides, namespace string) (*RunObject, error) {
  563. err := generate.ValidateParams(names, params)
  564. if err != nil {
  565. return nil, err
  566. }
  567. // TODO: Validate flag usage against selected generator. More tricky since --expose was added.
  568. obj, err := generator.Generate(params)
  569. if err != nil {
  570. return nil, err
  571. }
  572. mapper, err := f.ToRESTMapper()
  573. if err != nil {
  574. return nil, err
  575. }
  576. // run has compiled knowledge of the thing is creating
  577. gvks, _, err := scheme.Scheme.ObjectKinds(obj)
  578. if err != nil {
  579. return nil, err
  580. }
  581. mapping, err := mapper.RESTMapping(gvks[0].GroupKind(), gvks[0].Version)
  582. if err != nil {
  583. return nil, err
  584. }
  585. if len(overrides) > 0 {
  586. codec := runtime.NewCodec(scheme.DefaultJSONEncoder(), scheme.Codecs.UniversalDecoder(scheme.Scheme.PrioritizedVersionsAllGroups()...))
  587. obj, err = cmdutil.Merge(codec, obj, overrides)
  588. if err != nil {
  589. return nil, err
  590. }
  591. }
  592. if err := o.Recorder.Record(obj); err != nil {
  593. klog.V(4).Infof("error recording current command: %v", err)
  594. }
  595. actualObj := obj
  596. if !o.DryRun {
  597. if err := kubectl.CreateOrUpdateAnnotation(cmdutil.GetFlagBool(cmd, cmdutil.ApplyAnnotationsFlag), obj, scheme.DefaultJSONEncoder()); err != nil {
  598. return nil, err
  599. }
  600. client, err := f.ClientForMapping(mapping)
  601. if err != nil {
  602. return nil, err
  603. }
  604. actualObj, err = resource.NewHelper(client, mapping).Create(namespace, false, obj, nil)
  605. if err != nil {
  606. return nil, err
  607. }
  608. }
  609. return &RunObject{
  610. Object: actualObj,
  611. Mapping: mapping,
  612. }, nil
  613. }