Kubernetes Visitor设计模式及发送pod创建请求解析

// visitor 即为访问者这个对象
type visitor interface {
	visit(visitorfunc) error
}
// visitorfunc对应这个对象的方法，也就是定义中的“操作”
type visitorfunc func(*info, error) error

// visitorlist定义为[]visitor，又实现了visit方法，也就是将多个[]visitor封装为一个visitor
type visitorlist []visitor
// 发生error就立刻返回，不继续遍历
func (l visitorlist) visit(fn visitorfunc) error {
	for i := range l {
		if err := l[i].visit(fn); err != nil {
			return err
		}
	}
	return nil
}

// eagervisitorlist 也是将多个[]visitor封装为一个visitor
type eagervisitorlist []visitor
// 返回的错误暂存到[]error中，统一聚合
func (l eagervisitorlist) visit(fn visitorfunc) error {
	errs := []error(nil)
	for i := range l {
		if err := l[i].visit(func(info *info, err error) error {
			if err != nil {
				errs = append(errs, err)
				return nil
			}
			if err := fn(info, nil); err != nil {
				errs = append(errs, err)
			}
			return nil
		}); err != nil {
			errs = append(errs, err)
		}
	}
	return utilerrors.newaggregate(errs)
}

// 装饰器visitor
type decoratedvisitor struct {
	visitor    visitor
	decorators []visitorfunc
}
// visitor遍历调用decorators中所有函数，有失败立即返回
func (v decoratedvisitor) visit(fn visitorfunc) error {
	return v.visitor.visit(func(info *info, err error) error {
		if err != nil {
			return err
		}
		for i := range v.decorators {
			if err := v.decorators[i](info, nil); err != nil {
				return err
			}
		}
		return fn(info, nil)
	})
}

// 报错依旧继续
type continueonerrorvisitor struct {
	visitor
}
// 报错不立即返回，聚合所有错误后返回
func (v continueonerrorvisitor) visit(fn visitorfunc) error {
	errs := []error{}
	err := v.visitor.visit(func(info *info, err error) error {
		if err != nil {
			errs = append(errs, err)
			return nil
		}
		if err := fn(info, nil); err != nil {
			errs = append(errs, err)
		}
		return nil
	})
	if err != nil {
		errs = append(errs, err)
	}
	if len(errs) == 1 {
		return errs[0]
	}
	return utilerrors.newaggregate(errs)
}

type flattenlistvisitor struct {
	visitor visitor
	typer   runtime.objecttyper
	mapper  *mapper
}

// 过滤的info
type filteredvisitor struct {
	visitor visitor
	filters []filterfunc
}
func (v filteredvisitor) visit(fn visitorfunc) error {
	return v.visitor.visit(func(info *info, err error) error {
		if err != nil {
			return err
		}
		for _, filter := range v.filters {
      // 检验info是否满足条件，出错则退出
			ok, err := filter(info, nil)
			if err != nil {
				return err
			}
			if !ok {
				return nil
			}
		}
		return fn(info, nil)
	})
}

type streamvisitor struct {
  // 读取信息的来源，实现了read这个接口，这个"流式"的概念，包括了常见的http、文件、标准输入等各类输入
	io.reader
	*mapper
	source string
	schema contentvalidator
}

type filevisitor struct {
  // 表示文件路径或者stdin
	path string
	*streamvisitor
}

type urlvisitor struct {
	url *url.url
	*streamvisitor
  // 提供错误重试次数
	httpattemptcount int
}

type kustomizevisitor struct {
	path string
	*streamvisitor
}

// 在runcreate函数中，关键的发送函数
obj, err := resource.
				newhelper(info.client, info.mapping).
				dryrun(o.dryrunstrategy == cmdutil.dryrunserver).
				withfieldmanager(o.fieldmanager).
				create(info.namespace, true, info.object)
// 进入create函数，查看到
m.createresource(m.restclient, m.resource, namespace, obj, options)
// 对应的实现为
func (m *helper) createresource(c restclient, resource, namespace string, obj runtime.object, options *metav1.createoptions) (runtime.object, error) {
	return c.post().
		namespaceifscoped(namespace, m.namespacescoped).
		resource(resource).
		versionedparams(options, metav1.parametercodec).
		body(obj).
		do(context.todo()).
		get()
}
/*
到这里，我们发现了2个关键性的定义:
1. restclient 与kube-apiserver交互的restful风格的客户端 这个restclient是来自于builder时的传入，生成的result，底层是一个newclientwithoptions生成的
2. runtime.object 资源对象的抽象，包括pod/deployment/service等各类资源
3. 我们是传入的文件，是filevisitor来执行的，底层builder.mapper调用decode来生成obj(unstructured())
*/

// 从传入参数来看，数据来源于info这个结构
r.visit(func(info *resource.info, err error) error{})
// 而info来源于前面的builder，前面部分都是将builder参数化，核心的生成为do函数
r := f.newbuilder().
		unstructured().
		schema(schema).
		continueonerror().
		namespaceparam(cmdnamespace).defaultnamespace().
		filenameparam(enforcenamespace, &o.filenameoptions).
		labelselectorparam(o.selector).
		flatten().
		do()
// 大致看一下这些函数，我们可以在unstructured()中看到getclient函数，其实这就是我们要找的函数
func (b *builder) getclient(gv schema.groupversion) (restclient, error) 
// 从返回值来看，client包括默认的rest client和配置选项
newclientwithoptions(client, b.requesttransforms...)
// 这个client会在kubernetes项目中大量出现，它是与kube-apiserver交互的核心组件，以后再深入。

func (v *filevisitor) visit(fn visitorfunc) error {
	// 省略读取这块的代码，底层调用的是streamvisitor的逻辑
	return v.streamvisitor.visit(fn)
}
func (v *streamvisitor) visit(fn visitorfunc) error {
	d := yaml.newyamlorjsondecoder(v.reader, 4096)
	for {
		// 这里就是返回info的地方
		info, err := v.infofordata(ext.raw, v.source)
  }
}
// 再往下一层看，来到mapper层，也就是kubernetes的资源对象映射关系
func (m *mapper) infofordata(data []byte, source string) (*info, error){
  // 这里就是我们返回object的地方，其中gvk是group/version/kind的缩写，后续我们会涉及
  obj, gvk, err := m.decoder.decode(data, nil, nil)
}

// 在builder初始化中，我们就找到了
func (b *builder) unstructured() *builder {
	b.mapper = &mapper{
		localfn:      b.islocal,
		restmapperfn: b.restmapperfn,
		clientfn:     b.getclient,
    // 我们查找资源用到的是这个decoder
		decoder:      &metadatavalidatingdecoder{unstructured.unstructuredjsonscheme},
	}
	return b
}
// 逐层往下找，对应的decode方法的实现，就是对应的数据解析成data：
func (s unstructuredjsonscheme) decode(data []byte) (runtime.object, error) {
	// 细节暂时忽略
}

// restful接口风格中，post请求对应的就是create方法
c.post().
		namespaceifscoped(namespace, m.namespacescoped).
		resource(resource).
		versionedparams(options, metav1.parametercodec).
		body(obj).
		do(context.todo()). 
		get() 
// do方法，发送请求
err := r.request(ctx, func(req *http.request, resp *http.response) {
		result = r.transformresponse(resp, req)
	})
// get方法，获取请求的返回结果，用来打印状态
switch t := out.(type) {
	case *metav1.status:
		if t.status != metav1.statussuccess {
			return nil, errors.fromobject(t)
		}
	}