CoreDNS 插件系统的实现原理

1
2

.PHONY: check
check: presubmit core/zplugin.go core/dnsserver/zdirectives.go godeps

1
2

core/zplugin.go core/dnsserver/zdirectives.go: plugin.cfg
	go generate coredns.go

1
2
3

...
//go:generate go run directives_generate.go
...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

// generated by directives_generate.go; DO NOT EDIT

package plugin

import (
	// Include all plugins.
	_ "github.com/coredns/coredns/plugin/auto"
	_ "github.com/coredns/coredns/plugin/autopath"
	_ "github.com/coredns/coredns/plugin/bind"
	_ "github.com/coredns/coredns/plugin/cache"
	_ "github.com/coredns/coredns/plugin/chaos"
	_ "github.com/coredns/coredns/plugin/debug"
	_ "github.com/coredns/coredns/plugin/dnssec"
	_ "github.com/coredns/coredns/plugin/dnstap"
	_ "github.com/coredns/coredns/plugin/erratic"
	_ "github.com/coredns/coredns/plugin/errors"
	_ "github.com/coredns/coredns/plugin/etcd"
	_ "github.com/coredns/coredns/plugin/federation"
	_ "github.com/coredns/coredns/plugin/file"
	_ "github.com/coredns/coredns/plugin/forward"
	_ "github.com/coredns/coredns/plugin/health"
	_ "github.com/coredns/coredns/plugin/hosts"
	_ "github.com/coredns/coredns/plugin/kubernetes"
	_ "github.com/coredns/coredns/plugin/loadbalance"
	_ "github.com/coredns/coredns/plugin/log"
	_ "github.com/coredns/coredns/plugin/loop"
	_ "github.com/coredns/coredns/plugin/metadata"
	_ "github.com/coredns/coredns/plugin/metrics"
	_ "github.com/coredns/coredns/plugin/nsid"
	_ "github.com/coredns/coredns/plugin/pprof"
	_ "github.com/coredns/coredns/plugin/proxy"
	_ "github.com/coredns/coredns/plugin/reload"
	_ "github.com/coredns/coredns/plugin/rewrite"
	_ "github.com/coredns/coredns/plugin/root"
	_ "github.com/coredns/coredns/plugin/route53"
	_ "github.com/coredns/coredns/plugin/secondary"
	_ "github.com/coredns/coredns/plugin/template"
	_ "github.com/coredns/coredns/plugin/tls"
	_ "github.com/coredns/coredns/plugin/trace"
	_ "github.com/coredns/coredns/plugin/whoami"
	_ "github.com/mholt/caddy/onevent"
)

1
2
3
4
5
6

func init() {
	caddy.RegisterPlugin("auto", caddy.Plugin{
		ServerType: "dns",
		Action:     setup,
	})
}

1
2
3
4

func setup(c *caddy.Controller) error {
    // 注册插件的时候将会运行这个函数
    // 主要用于配置解析等一些初始化工作
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

// generated by directives_generate.go; DO NOT EDIT

package dnsserver

// Directives are registered in the order they should be
// executed.
//
// Ordering is VERY important. Every plugin will
// feel the effects of all other plugin below
// (after) them during a request, but they must not
// care what plugin above them are doing.
var Directives = []string{
	"metadata",
	"tls",
	"reload",
	"nsid",
	"root",
	"bind",
	"debug",
	"trace",
	"health",
	"pprof",
	"prometheus",
	"errors",
	"log",
	"dnstap",
	"chaos",
	"loadbalance",
	"cache",
	"rewrite",
	"dnssec",
	"autopath",
	"template",
	"hosts",
	"route53",
	"federation",
	"kubernetes",
	"file",
	"auto",
	"secondary",
	"etcd",
	"loop",
	"forward",
	"proxy",
	"erratic",
	"whoami",
	"on",
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// Any flags defined here, need to be namespaced to the serverType other
// wise they potentially clash with other server types.
func init() {
	flag.StringVar(&Port, serverType+".port", DefaultPort, "Default port")

	caddy.RegisterServerType(serverType, caddy.ServerType{
		Directives: func() []string { return Directives },
		DefaultInput: func() caddy.Input {
			return caddy.CaddyfileInput{
				Filepath:       "Corefile",
				Contents:       []byte(".:" + Port + " {\nwhoami\n}\n"),
				ServerTypeName: serverType,
			}
		},
		NewContext: newContext,
	})
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

func executeDirectives(inst *Instance, filename string,
	directives []string, sblocks []caddyfile.ServerBlock, justValidate bool) error {
	// ...
	for _, dir := range directives {
		for i, sb := range sblocks {
			// ...
			for j, key := range sb.Keys {
				// Execute directive if it is in the server block
				if tokens, ok := sb.Tokens[dir]; ok {
					// ...
					setup, err := DirectiveAction(inst.serverType, dir)
					if err != nil {
						return err
					}

					err = setup(controller)
					// ...
				}
			}
		}
		// ...
	}
	// ...
}

1
2
3
4
5
6

metadata:metadata
tls:tls
reload:reload
nsid:nsid
root:root
...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

package main

//go:generate go run directives_generate.go

import (
	"github.com/coredns/coredns/coremain"

	// Plug in CoreDNS
	_ "github.com/coredns/coredns/core/plugin"
)

func main() {
	coremain.Run()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

package coremain

import (
	// ...

	"github.com/coredns/coredns/core/dnsserver"
	
	// ...
)

func Run() {
	caddy.TrapSignals()
	// ...

	// 获取 Caddy 的配置，生成对应的配置文件结构 corefile
	corefile, err := caddy.LoadCaddyfile(serverType)
	// ...

	// 以 corefile 为配置启动 Caddy
	instance, err := caddy.Start(corefile)
	// ...
	
	// Execute instantiation events
	caddy.EmitEvent(caddy.InstanceStartupEvent, instance)

	// Twiddle your thumbs
	instance.Wait()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

func init() {
	flag.StringVar(&Port, serverType+".port", DefaultPort, "Default port")

	caddy.RegisterServerType(serverType, caddy.ServerType{
		Directives: func() []string { return Directives },
		DefaultInput: func() caddy.Input {
			return caddy.CaddyfileInput{
				Filepath:       "Corefile",
				Contents:       []byte(".:" + Port + " {\nwhoami\n}\n"),
				ServerTypeName: serverType,
			}
		},
		NewContext: newContext,
	})
}

1
2
3

func newContext(i *caddy.Instance) caddy.Context {
	return &dnsContext{keysToConfigs: make(map[string]*Config)}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

type Context interface {
	// Called after the Caddyfile is parsed into server
	// blocks but before the directives are executed,
	// this method gives you an opportunity to inspect
	// the server blocks and prepare for the execution
	// of directives. Return the server blocks (which
	// you may modify, if desired) and an error, if any.
	// The first argument is the name or path to the
	// configuration file (Caddyfile).
	//
	// This function can be a no-op and simply return its
	// input if there is nothing to do here.
	InspectServerBlocks(string, []caddyfile.ServerBlock) ([]caddyfile.ServerBlock, error)

	// This is what Caddy calls to make server instances.
	// By this time, all directives have been executed and,
	// presumably, the context has enough state to produce
	// server instances for Caddy to start.
	MakeServers() ([]Server, error)
}

1
2
3

for _, plugin := range plugins {
    plugin()
}

1
2
3
4
5
6
7
8

type (
	Handler interface {
		// 每个插件处理请求的逻辑
		ServeDNS(context.Context, dns.ResponseWriter, *dns.Msg) (int, error)
		// 返回插件名
		Name() string
	}
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// 定义一个空的 struct
type Whoami struct{}

// 给 Whoami 对象实现 ServeDNS 方法
// w 是用来写入响应
// r 是接收到的 DNS 请求
func (wh Whoami) ServeDNS(ctx context.Context, w dns.ResponseWriter, r *dns.Msg) (int, error) {
    // ...
}

// 给 Whoami 对象实现 Name 方法
// 只需要简单返回插件名字的字符串即可
func (wh Whoami) Name() string { return "whoami" }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

func setup(c *caddy.Controller) error {
    // 通常前面是做一些参数解析的逻辑
    
    // dnsserver 层添加插件
    // next 表示的是下一个插件
    dnsserver.GetConfig(c).AddPlugin(func(next plugin.Handler) plugin.Handler {
		l.Next = next
		return l
	})
	
	// ...  
}

1
2
3

func (c *Config) AddPlugin(m plugin.Plugin) {
	c.Plugin = append(c.Plugin, m)
}

1
2
3

func(next plugin.Handler) plugin.Handler {
    ...
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

func NewServer(addr string, group []*Config) (*Server, error) {
		// ...
		var stack plugin.Handler
		// 从插件列表的最后一个元素开始
		for i := len(site.Plugin) - 1; i >= 0; i-- {
		// stack 作为此时插件的 next 参数
		// 如果配置文件中的插件顺序是 A,B,C,D，首次初始化时添加到列表就会变成 D,C,B,A
		// 从最后一个元素 A，开始依次调用对应的 plugin.Handler，将有：
		// A: next=nil
		// B: next=A
		// C: next=B
		// D: next=C
		// 最终插件从 D 开始，即原来配置顺序的最后一个
		// 最终的执行顺序为配置文件插件顺序的逆序
		stack = site.Plugin[i](stack)

		// register the *handler* also
		site.registerHandler(stack)
			// ...
		}
		// 这时的插件是配置文件顺序中的最后一个
		site.pluginChain = stack
		// ...
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

// coredns/core/dnsserver/register.go
func (h *dnsContext) MakeServers() ([]caddy.Server, error) {
	// ...
	var servers []caddy.Server
	// 由于我们可以定义多个 group 来对不同的域名做解析
	// 每个 group 都将创建一个不同的 DNS server 的实例
	for addr, group := range groups {
		// switch on addr
		switch tr, _ := parse.Transport(addr); tr {
		case transport.DNS:
			s, err := NewServer(addr, group)
			if err != nil {
				return nil, err
			}
			servers = append(servers, s)

		case transport.TLS:
			s, err := NewServerTLS(addr, group)
			if err != nil {
				return nil, err
			}
			servers = append(servers, s)

		case transport.GRPC:
			s, err := NewServergRPC(addr, group)
			if err != nil {
				return nil, err
			}
			servers = append(servers, s)

		case transport.HTTPS:
			s, err := NewServerHTTPS(addr, group)
			if err != nil {
				return nil, err
			}
			servers = append(servers, s)
		}

	}

	return servers, nil
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

// coredns/core/dnsserver/server.go
func (s *Server) ServeDNS(ctx context.Context, w dns.ResponseWriter, r *dns.Msg) {
        //...

        // 如果请求落在对应的 zone，执行 zone 内的插件
        if h, ok := s.zones[string(b[:l])]; ok {
                //...
                if r.Question[0].Qtype != dns.TypeDS {
                        // 如果没有过滤函数
                        if h.FilterFunc == nil {
                                // 执行插件链上上的插件
                                // 如果插件中有 NextOrFailure() 则将跳至下一个插件
                                // 否则则直接返回
                                rcode, _ := h.pluginChain.ServeDNS(ctx, w, r)
                                if !plugin.ClientWrite(rcode) {
                                        DefaultErrorFunc(ctx, w, r, rcode)
                                }
                                return
                        }
                        // FilterFunc is set, call it to see if we should use this handler.
                        // This is given to full query name.
                        if h.FilterFunc(q) {
                                rcode, _ := h.pluginChain.ServeDNS(ctx, w, r)
                                if !plugin.ClientWrite(rcode) {
                                        DefaultErrorFunc(ctx, w, r, rcode)
                                }
                                return
                        }
                }
        }
        //...
}