Go 插件系统与 WebAssembly 扩展

// plugin/greeter/greeter.go
// 编译：go build -buildmode=plugin -o greeter.so greeter.go
package main

type Greeter struct{}

func (g *Greeter) Greet(name string) string {
    return "Hello, " + name + " from plugin!"
}

// 导出的符号
var GreeterPlugin Greeter

// main.go
package main

import (
    "fmt"
    "plugin"
)

type GreetInterface interface {
    Greet(name string) string
}

func main() {
    // 加载插件
    p, err := plugin.Open("plugin/greeter/greeter.so")
    if err != nil {
        panic(err)
    }
    
    // 查找符号
    sym, err := p.Lookup("GreeterPlugin")
    if err != nil {
        panic(err)
    }
    
    // 类型断言
    greeter, ok := sym.(*GreeterInterface)
    if !ok {
        panic("unexpected type")
    }
    
    fmt.Println(greeter.Greet("World"))
}

// shared/interface.go
package shared

import "github.com/hashicorp/go-plugin"

// Greeter 是插件需要实现的接口
type Greeter interface {
    Greet(name string) (string, error)
}

// Handshake 协议：主进程和插件进程之间的"暗号"
var HandshakeConfig = plugin.HandshakeConfig{
    ProtocolVersion:  1,
    MagicCookieKey:   "GREETER_PLUGIN",
    MagicCookieValue: "hello",
}

// PluginMap 是插件可以提供的服务注册表
var PluginMap = map[string]plugin.Plugin{
    "greeter": &GreeterPlugin{},
}

// plugin/greeter.go
package main

import (
    "github.com/hashicorp/go-plugin"
    "example/shared"
)

// GreeterRPC 是实现 shared.Greeter 的具体类型
type GreeterRPC struct{}

func (g *GreeterRPC) Greet(name string) (string, error) {
    return "Hello, " + name + "!", nil
}

type GreeterPlugin struct {
    plugin.NetRPCUnsupportedPlugin
    Impl shared.Greeter
}

func (p *GreeterPlugin) Server(*plugin.MuxBroker) (interface{}, error) {
    return &GreeterRPCServer{Impl: p.Impl}, nil
}

func (p *GreeterPlugin) Client(b *plugin.MuxBroker, c *rpc.Client) (interface{}, error) {
    return &GreeterRPC{client: c}, nil
}

func main() {
    plugin.Serve(&plugin.ServeConfig{
        HandshakeConfig: shared.HandshakeConfig,
        Plugins:         shared.PluginMap,
    })
}

// main.go
package main

import (
    "github.com/hashicorp/go-plugin"
    "example/shared"
    "os/exec"
)

func main() {
    client := plugin.NewClient(&plugin.ClientConfig{
        HandshakeConfig: shared.HandshakeConfig,
        Plugins:         shared.PluginMap,
        Cmd:             exec.Command("./plugin/greeter"),
        AllowedProtocols: []plugin.Protocol{plugin.ProtocolNetRPC, plugin.ProtocolGRPC},
    })
    defer client.Kill()
    
    rpcClient, err := client.Client()
    if err != nil {
        panic(err)
    }
    
    raw, err := rpcClient.Dispense("greeter")
    if err != nil {
        panic(err)
    }
    
    greeter := raw.(shared.Greeter)
    msg, _ := greeter.Greet("World")
    fmt.Println(msg)
}

package main

import (
    "context"
    "fmt"
    "github.com/tetratelabs/wazero"
    "github.com/tetratelabs/wazero/imports/wasi_snapshot_preview1"
)

func main() {
    ctx := context.Background()
    
    // 创建 WASM 运行时
    r := wazero.NewRuntime(ctx)
    defer r.Close(ctx)
    
    // 添加 WASI 支持
    wasi_snapshot_preview1.MustInstantiate(ctx, r)
    
    // 加载 WASM 模块
    wasmBytes, _ := os.ReadFile("plugin.wasm")
    module, err := r.Instantiate(ctx, wasmBytes)
    if err != nil {
        panic(err)
    }
    
    // 调用 WASM 导出的函数
    greet := module.ExportedFunction("greet")
    
    // 分配内存并写入参数
    alloc := module.ExportedFunction("alloc")
    results, _ := alloc.Call(ctx, uint64(len("World")))
    ptr := results[0]
    
    // 写入内存
    mem, _ := module.Memory().WriteString(uint32(ptr), "World")
    
    // 调用 greet
    greetResults, _ := greet.Call(ctx, ptr, uint64(len("World")))
    resultPtr := greetResults[0]
    resultLen := greetResults[1]
    
    // 读取结果
    msg, _ := module.Memory().ReadString(uint32(resultPtr), uint32(resultLen))
    fmt.Println(msg)
}

// plugin/main.go (编译为 WASM)
// GOOS=js GOARCH=wasm tinygo build -o plugin.wasm main.go
package main

import "unsafe"

//go:export alloc
func alloc(size uint32) *byte {
    buf := make([]byte, size)
    return &buf[0]
}

//go:export greet
func greet(ptr *byte, len uint32) (*byte, uint32) {
    name := C.GoStringN(ptr, C.int(len))
    msg := "Hello, " + name + " from WASM!"
    buf := []byte(msg)
    return &buf[0], uint32(len(buf))
}

func main() {}

// 好的插件接口：小而稳定
package pluginiface

type Processor interface {
    Name() string                          // 插件标识
    Version() string                       // 版本
    Init(config map[string]string) error   // 初始化
    Process(ctx context.Context, input []byte) ([]byte, error)  // 处理
    Close() error                          // 清理
}

// ❌ 不要频繁修改接口
// ❌ 不要把内部数据结构暴露给插件
// ✅ 接口一旦发布，保持向后兼容

type PluginManager struct {
    plugins map[string]Plugin
    mu      sync.RWMutex
}

func (pm *PluginManager) Load(path string) error {
    // 1. 验证插件签名
    if !verifySignature(path) {
        return errors.New("invalid signature")
    }
    
    // 2. 加载插件
    plugin, err := loadPlugin(path)
    if err != nil {
        return err
    }
    
    // 3. 初始化
    if err := plugin.Init(nil); err != nil {
        return err
    }
    
    // 4. 注册
    pm.mu.Lock()
    pm.plugins[plugin.Name()] = plugin
    pm.mu.Unlock()
    
    return nil
}

func (pm *PluginManager) Unload(name string) error {
    pm.mu.Lock()
    defer pm.mu.Unlock()
    
    plugin, ok := pm.plugins[name]
    if !ok {
        return errors.New("plugin not found")
    }
    
    if err := plugin.Close(); err != nil {
        log.Printf("plugin %s close error: %v", name, err)
    }
    
    delete(pm.plugins, name)
    return nil
}