kubectl源码分析之create job命令

 欢迎关注我的公众号：

 目前刚开始写一个月，一共写了18篇原创文章，文章目录如下：

istio多集群探秘，部署了50次多集群后我得出的结论

istio多集群链路追踪，附实操视频

istio防故障利器，你知道几个,istio新手不要读，太难！

istio业务权限控制，原来可以这么玩

istio实现非侵入压缩，微服务之间如何实现压缩

不懂envoyfilter也敢说精通istio系列-http-rbac-不要只会用AuthorizationPolicy配置权限

不懂envoyfilter也敢说精通istio系列-02-http-corsFilter-不要只会vs

不懂envoyfilter也敢说精通istio系列-03-http-csrf filter-再也不用再代码里写csrf逻辑了

不懂envoyfilter也敢说精通istio系列http-jwt_authn-不要只会RequestAuthorization

不懂envoyfilter也敢说精通istio系列-05-fault-filter-故障注入不止是vs

不懂envoyfilter也敢说精通istio系列-06-http-match-配置路由不只是vs

不懂envoyfilter也敢说精通istio系列-07-负载均衡配置不止是dr

不懂envoyfilter也敢说精通istio系列-08-连接池和断路器

不懂envoyfilter也敢说精通istio系列-09-http-route filter

不懂envoyfilter也敢说精通istio系列-network filter-redis proxy

不懂envoyfilter也敢说精通istio系列-network filter-HttpConnectionManager

不懂envoyfilter也敢说精通istio系列-ratelimit-istio ratelimit完全手册

 

————————————————--------------------------------------------------------------------------------------

type CreateJobOptions struct {//create job结构体
	PrintFlags *genericclioptions.PrintFlags

	PrintObj func(obj runtime.Object) error

	Name    string
	Image   string
	From    string
	Command []string

	Namespace string
	Client    batchv1client.BatchV1Interface
	DryRun    bool
	Builder   *resource.Builder
	Cmd       *cobra.Command

	genericclioptions.IOStreams
}

func NewCreateJobOptions(ioStreams genericclioptions.IOStreams) *CreateJobOptions {
	return &CreateJobOptions{//初始化create job结构体
		PrintFlags: genericclioptions.NewPrintFlags("created").WithTypeSetter(scheme.Scheme),
		IOStreams:  ioStreams,
	}
}

//创建create job命令
func NewCmdCreateJob(f cmdutil.Factory, ioStreams genericclioptions.IOStreams) *cobra.Command {
	o := NewCreateJobOptions(ioStreams)//初始化结构体
	cmd := &cobra.Command{//创建cobra命令
		Use:     "job NAME --image=image [--from=cronjob/name] -- [COMMAND] [args...]",
		Short:   jobLong,
		Long:    jobLong,
		Example: jobExample,
		Run: func(cmd *cobra.Command, args []string) {
			cmdutil.CheckErr(o.Complete(f, cmd, args))// 准备
			cmdutil.CheckErr(o.Validate())//校验
			cmdutil.CheckErr(o.Run())//运行
		},
	}

	o.PrintFlags.AddFlags(cmd)//设置print选项

	cmdutil.AddApplyAnnotationFlags(cmd)//设置save-config选项
	cmdutil.AddValidateFlags(cmd)//设置validate选项
	cmdutil.AddDryRunFlag(cmd)//设置dry-run选项
	cmd.Flags().StringVar(&o.Image, "image", o.Image, "Image name to run.")//设置image选项
	cmd.Flags().StringVar(&o.From, "from", o.From, "The name of the resource to create a Job from (only cronjob is supported).")//设置from选项

	return cmd
}

//准备方法
func (o *CreateJobOptions) Complete(f cmdutil.Factory, cmd *cobra.Command, args []string) error {
	name, err := NameFromCommandArgs(cmd, args)//获取名称
	if err != nil {
		return err
	}
	o.Name = name//设置名称
	if len(args) > 1 {
		o.Command = args[1:]//设置command参数
	}

	clientConfig, err := f.ToRESTConfig()//获取restConfig
	if err != nil {
		return err
	}
	o.Client, err = batchv1client.NewForConfig(clientConfig)//根据restConfig获取client
	if err != nil {
		return err
	}

	o.Namespace, _, err = f.ToRawKubeConfigLoader().Namespace()//设置namespace
	if err != nil {
		return err
	}
	o.Builder = f.NewBuilder()//设置builder
	o.Cmd = cmd//设置cmd

	o.DryRun = cmdutil.GetDryRunFlag(cmd)//设置干跑
	if o.DryRun {
		o.PrintFlags.Complete("%s (dry run)")
	}
	printer, err := o.PrintFlags.ToPrinter()//print flag转printer
	if err != nil {
		return err
	}
	o.PrintObj = func(obj runtime.Object) error {//设置printObj函数
		return printer.PrintObj(obj, o.Out)
	}

	return nil
}

//校验
func (o *CreateJobOptions) Validate() error {
	if (len(o.Image) == 0 && len(o.From) == 0) || (len(o.Image) != 0 && len(o.From) != 0) {
		return fmt.Errorf("either --image or --from must be specified")//image和from只能指定一个
	}
	if o.Command != nil && len(o.Command) != 0 && len(o.From) != 0 {//command和from不能同时指定
		return fmt.Errorf("cannot specify --from and command")
	}
	return nil
}

//运行命令
func (o *CreateJobOptions) Run() error {
	var job *batchv1.Job
	if len(o.Image) > 0 {//如果指定了image
		job = o.createJob()//构造job对象
	} else {//如果指定了from
		infos, err := o.Builder.
			Unstructured().
			NamespaceParam(o.Namespace).DefaultNamespace().
			ResourceTypeOrNameArgs(false, o.From).
			Flatten().
			Latest().
			Do().
			Infos()//获取cronjob info对象
		if err != nil {
			return err
		}
		if len(infos) != 1 {//info必须是一个
			return fmt.Errorf("from must be an existing cronjob")
		}

		uncastVersionedObj, err := scheme.Scheme.ConvertToVersion(infos[0].Object, batchv1beta1.SchemeGroupVersion)
		if err != nil {
			return fmt.Errorf("from must be an existing cronjob: %v", err)
		}
		cronJob, ok := uncastVersionedObj.(*batchv1beta1.CronJob)//把obj转为cronJob
		if !ok {
			return fmt.Errorf("from must be an existing cronjob")
		}

		job = o.createJobFromCronJob(cronJob)//从cronjob创建job
	}
	if !o.DryRun {
		var err error
		job, err = o.Client.Jobs(o.Namespace).Create(job)//用client创建job
		if err != nil {
			return fmt.Errorf("failed to create job: %v", err)
		}
	}

	return o.PrintObj(job)//打印结果
}

func (o *CreateJobOptions) createJob() *batchv1.Job {
	return &batchv1.Job{//创建job对象
		// this is ok because we know exactly how we want to be serialized
		TypeMeta: metav1.TypeMeta{APIVersion: batchv1.SchemeGroupVersion.String(), Kind: "Job"},
		ObjectMeta: metav1.ObjectMeta{
			Name: o.Name,
		},
		Spec: batchv1.JobSpec{
			Template: corev1.PodTemplateSpec{
				Spec: corev1.PodSpec{
					Containers: []corev1.Container{
						{
							Name:    o.Name,
							Image:   o.Image,
							Command: o.Command,
						},
					},
					RestartPolicy: corev1.RestartPolicyNever,
				},
			},
		},
	}
}

//从cronjob创建job对象
func (o *CreateJobOptions) createJobFromCronJob(cronJob *batchv1beta1.CronJob) *batchv1.Job {
	annotations := make(map[string]string)
	annotations["cronjob.kubernetes.io/instantiate"] = "manual"
	for k, v := range cronJob.Spec.JobTemplate.Annotations {
		annotations[k] = v
	}

	return &batchv1.Job{
		// this is ok because we know exactly how we want to be serialized
		TypeMeta: metav1.TypeMeta{APIVersion: batchv1.SchemeGroupVersion.String(), Kind: "Job"},
		ObjectMeta: metav1.ObjectMeta{
			Name:        o.Name,
			Annotations: annotations,
			Labels:      cronJob.Spec.JobTemplate.Labels,
			OwnerReferences: []metav1.OwnerReference{
				*metav1.NewControllerRef(cronJob, appsv1.SchemeGroupVersion.WithKind("CronJob")),
			},
		},
		Spec: cronJob.Spec.JobTemplate.Spec,
	}
}