阅读 349

go-micro 动态加载插件源码分析

go-micro 框架支持动态加载插件,无需修改代码。

源码分析

启动服务前,设定 MICRO_PLUGIN 环境变量指定 .so 文件路径,支持多个插件,逗号分割。程序启动前会读取 MICRO_PLUGIN 环境变量,并完成插件设定。

下面是其内部实现:

go-micro/service.go

func (s *service) Init(opts ...Option) {
...

	// setup the plugins
	for _, p := range strings.Split(os.Getenv("MICRO_PLUGIN"), ",") {
		if len(p) == 0 {
			continue
		}

		// load the plugin
		c, err := plugin.Load(p)
		if err != nil {
			logger.Fatal(err)
		}

		// initialise the plugin
		if err := plugin.Init(c); err != nil {
			logger.Fatal(err)
		}
	}
复制代码

从上面的代码可以看出,service 初始化化的时候,读取 MICRO_PLUGIN 环境变量中指定的 .so 文件路径。并且调用 plugin 包,逐个 Init

下面我们看下 plugin 包的实现:

plugin ├── default.go ├── plugin.go └── template.go

0 directories, 3 files

plugin 包的实现非常简单,只有三个文件。

go-micro/plugin/plugin.go

// Plugin is a plugin loaded from a file
type Plugin interface {
	// Initialise a plugin with the config
	Init(c *Config) error
	// Load loads a .so plugin at the given path
	Load(path string) (*Config, error)
	// Build a .so plugin with config at the path specified
	Build(path string, c *Config) error
}
复制代码

plugin 包定义了这样一个接口

  • Init(c *Config) error 方法用来注册插件;
  • Load(path string) (*Config, error) 用来加载一个 .so 文件,并返回一个 Config ;
  • Build(path string, c *Config) error 用来根据指定的 Config 变量生成一个 .so 文件。

go-micro 提供了一个默认的实现,在 go-micro/plugin/default.go 。

先来看一下默认实现的 Load 方法:

import (
//...
	pg "plugin"
//...
)

// Load loads a plugin created with `go build -buildmode=plugin`
func (p *plugin) Load(path string) (*Config, error) {
	plugin, err := pg.Open(path)
	if err != nil {
		return nil, err
	}
	s, err := plugin.Lookup("Plugin")
	if err != nil {
		return nil, err
	}
	pl, ok := s.(*Config)
	if !ok {

		return nil, errors.New("could not cast Plugin object")
	}
	return pl, nil
}
复制代码

Load 方法主要就是调用标准库 plugin open 一个 .so 文件,然后寻找 Plugin 这个变量,并通过类型断言它转换成 *Config 。Config 是 go-micro 定义的一个类型:

// Config is the plugin config
type Config struct {
	// Name of the plugin e.g rabbitmq
	Name string
	// Type of the plugin e.g broker
	Type string
	// Path specifies the import path
	Path string
	// NewFunc creates an instance of the plugin
	NewFunc interface{}
}
复制代码

关于标准库 plugin 的用法,这里不再描述可以查看源码文件,里面有用法说明。

package plugin

// Plugin is a loaded Go plugin.
type Plugin struct {
	pluginpath string
	err        string        // set if plugin failed to load
	loaded     chan struct{} // closed when loaded
	syms       map[string]interface{}
}

// Open opens a Go plugin.
// If a path has already been opened, then the existing *Plugin is returned.
// It is safe for concurrent use by multiple goroutines.
func Open(path string) (*Plugin, error) {
	return open(path)
}

// Lookup searches for a symbol named symName in plugin p.
// A symbol is any exported variable or function.
// It reports an error if the symbol is not found.
// It is safe for concurrent use by multiple goroutines.
func (p *Plugin) Lookup(symName string) (Symbol, error) {
	return lookup(p, symName)
}

// A Symbol is a pointer to a variable or function.
//
// For example, a plugin defined as
//
//	package main
//
//	import "fmt"
//
//	var V int
//
//	func F() { fmt.Printf("Hello, number %d\n", V) }
//
// may be loaded with the Open function and then the exported package
// symbols V and F can be accessed
//
//	p, err := plugin.Open("plugin_name.so")
//	if err != nil {
//		panic(err)
//	}
//	v, err := p.Lookup("V")
//	if err != nil {
//		panic(err)
//	}
//	f, err := p.Lookup("F")
//	if err != nil {
//		panic(err)
//	}
//	*v.(*int) = 7
//	f.(func())() // prints "Hello, number 7"
type Symbol interface{}
复制代码

我们继续看 go-micro 的 Init 方法实现:

// Init sets up the plugin
func (p *plugin) Init(c *Config) error {
	switch c.Type {
	case "broker":
		pg, ok := c.NewFunc.(func(...broker.Option) broker.Broker)
		if !ok {
			return fmt.Errorf("Invalid plugin %s", c.Name)
		}
		cmd.DefaultBrokers[c.Name] = pg
	case "client":
		pg, ok := c.NewFunc.(func(...client.Option) client.Client)
		if !ok {
			return fmt.Errorf("Invalid plugin %s", c.Name)
		}
		cmd.DefaultClients[c.Name] = pg
	case "registry":
		pg, ok := c.NewFunc.(func(...registry.Option) registry.Registry)
		if !ok {
			return fmt.Errorf("Invalid plugin %s", c.Name)
		}
		cmd.DefaultRegistries[c.Name] = pg

	case "selector":
		pg, ok := c.NewFunc.(func(...selector.Option) selector.Selector)
		if !ok {
			return fmt.Errorf("Invalid plugin %s", c.Name)
		}
		cmd.DefaultSelectors[c.Name] = pg
	case "server":
		pg, ok := c.NewFunc.(func(...server.Option) server.Server)
		if !ok {
			return fmt.Errorf("Invalid plugin %s", c.Name)
		}
		cmd.DefaultServers[c.Name] = pg
	case "transport":
		pg, ok := c.NewFunc.(func(...transport.Option) transport.Transport)
		if !ok {
			return fmt.Errorf("Invalid plugin %s", c.Name)
		}
		cmd.DefaultTransports[c.Name] = pg
	default:
		return fmt.Errorf("Unknown plugin type: %s for %s", c.Type, c.Name)
	}

	return nil
}
复制代码

这个函数是 micro 实现动态加载的重点,Init 函数通过 Load 方法返回的 Config 变量进行选择,然后通过类型转换得到 对应的构建函数赋值给 go-micro 的 cmd 包里的全局变量 DefaultXXXs

go-micro/config/cmd/cmd.go

	DefaultBrokers = map[string]func(...broker.Option) broker.Broker{
		"service": brokerSrv.NewBroker,
		"memory":  memory.NewBroker,
		"nats":    nats.NewBroker,
	}

	DefaultClients = map[string]func(...client.Option) client.Client{
		"mucp": cmucp.NewClient,
		"grpc": cgrpc.NewClient,
	}
复制代码

DefaultClients 为例,假设我们实现了一个 client 插件(需要实现 go-micro 的 client.Client 接口) 并实现了自己的创建函数 xrpc.NewClient 。那加载插件成功后, DefaultClients 变量就是

map[string]func(...client.Option) client.Client{
		"mucp": cmucp.NewClient,
		"grpc": cgrpc.NewClient,
		"xrpc": xrpc.NewClient,
	}
复制代码

在 cmd 对象的 Before 方法中会根据程序启动时传入的参数来选择对应的插件。

go-micro/config/cmd/cmd.go

// Set the client
if name := ctx.String("client"); len(name) > 0 {
		// only change if we have the client and type differs
	if cl, ok := c.opts.Clients[name]; ok && (*c.opts.Client).String() != name {
		*c.opts.Client = cl()
	}
}
复制代码

GLOBAL OPTIONS: --client value Client for go-micro; rpc [$MICRO_CLIENT]

如果启动程序时设定了 client=xrpc ,必须记得设定 MICRO_PLUGIN 环境变量指定动态库。这里设定的 c.opts.Client 会被 micro 服务所使用,可以一步一步向上追溯,这里就不追踪了。

上面的源码分析中,我们没有看 go-micro plugin 包的 Build 方法默认实现,现在我们来看一下:

// Build generates a dso plugin using the go command `go build -buildmode=plugin`
func (p *plugin) Build(path string, c *Config) error {
	path = strings.TrimSuffix(path, ".so")

	// create go file in tmp path
	temp := os.TempDir()
	base := filepath.Base(path)
	goFile := filepath.Join(temp, base+".go")

	// generate .go file
	if err := p.Generate(goFile, c); err != nil {
		return err
	}
	// remove .go file
	defer os.Remove(goFile)

	if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil && !os.IsExist(err) {
		return fmt.Errorf("Failed to create dir %s: %v", filepath.Dir(path), err)
	}
	cmd := exec.Command("go", "build", "-buildmode=plugin", "-o", path+".so", goFile)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	return cmd.Run()
}
复制代码

可以看出,主要就是更具传入的文件路径,创建目录,创建一个临时的go文件,然后调用 go build -buildmode=plugin 生成动态库。

这里调用的一个 Generate 方法,这个方法通过 go 模版生成 go 文件。

// Generate creates a go file at the specified path.
// You must use `go build -buildmode=plugin`to build it.
func (p *plugin) Generate(path string, c *Config) error {
	f, err := os.Create(path)
	if err != nil {
		return err
	}
	defer f.Close()
	t, err := template.New(c.Name).Parse(tmpl)
	if err != nil {
		return err
	}
	return t.Execute(f, c)
}

// ...

var (
	tmpl = `
package main

import (
	"github.com/micro/go-micro/v2/plugin"

	"{{.Path}}"
)

var Plugin = plugin.Config{
	Name: "{{.Name}}",
	Type: "{{.Type}}",
	Path: "{{.Path}}",
	NewFunc: {{.Name}}.{{.NewFunc}},
}
`
)
复制代码

根据模版生成 go 文件中会有一个全局变量 Plugin,这也印证了 Load 方法中的 plugin.Lookup("Plugin")

简单使用

package main

import (
	"fmt"
	"github.com/micro/go-micro/v2/plugin"
)

func main() {
	p := plugin.NewPlugin()
	if err := p.Build("/tmp/test.so", &plugin.Config{
		Name:    "client",
		Type:    "client",
		Path:    "github.com/micro/go-micro/v2/client",
		NewFunc: "NewClient",
	}); err != nil {
		panic(err)
	}

	c, err := plugin.Load("/tmp/test.so")
	if err != nil {
		panic(err)
	}

	fmt.Println(c.Name, c.Type, c.Path, c.NewFunc)
}
复制代码

上面的例子,主要是使用了 go-micro 的 plugin 包。先生成了 /tmp/test.so ,然后在 Load 这个动态库,打印 config 的内容。

当然也可以,不通过 plugin.Build 生成动态库,直接手写一个 go 文件,手动编译成动态库。

test.go

package main

import (
	"github.com/micro/go-micro/v2/client"

	"github.com/micro/go-micro/v2/plugin"
)

var Plugin = plugin.Config{
	Name:    "test",
	Type:    "client",
	Path:    "github.com/micro/go-micro/v2/client",
	NewFunc: client.NewClient,
}

复制代码
go build -buildmode=plugin -o ./test.so test.go
复制代码

go-micro 动态加载的主要场景

假设我们的 micro 服务 client 使用的是 grpc 的形式,现在希望改成 brpc 的形式。go-micro 支持的 client 插件中并不包含 brpc,我们自己使用 brpc 实现一个 client 插件,然后将其编译成动态库。

在运行环境 MICRO_PLUGIN 变量指定动态库路径,并且修改程序的启动命令,指定 client=brpc 。这样就可以做到无需重新编译二进制,替换自己想要的插件。

当然,自己在代码中重新 import 自己实现的插件库,显示指定 client 也是可以的。这样还可以将变更纳入版本管理,也是极好的。