Runtime Plugins

Plugins are a way of integrating external code into the Micro toolkit. This is completely separate to go-micro plugins. Using plugins here allows you to add additional flags, commands and HTTP handlers to the toolkit.

How it works

There is a global plugin manager under micro/plugin which consists of plugins that will be used across the entire toolkit. Plugins can be registered by calling plugin.Register. Each component (api, web, proxy, cli, bot) has a separate plugin manager used to register plugins which should only be added as part of that component. They can be used in the same way by called api.Register, web.Register, etc.

Here’s the interface

  1. // Plugin is the interface for plugins to micro. It differs from go-micro in that it's for
  2. // the micro API, Web, Proxy, CLI. It's a method of building middleware for the HTTP side.
  3. type Plugin interface {
  4.     // Global Flags
  5.     Flags() []cli.Flag
  6.     // Sub-commands
  7.     Commands() []cli.Command
  8.     // Handle is the middleware handler for HTTP requests. We pass in
  9.     // the existing handler so it can be wrapped to create a call chain.
  10.     Handler() Handler
  11.     // Init called when command line args are parsed.
  12.     // The initialised cli.Context is passed in.
  13.     Init(*cli.Context) error
  14.     // Name of the plugin
  15.     String() string
  16. }
  18. // Manager is the plugin manager which stores plugins and allows them to be retrieved.
  19. // This is used by all the components of micro.
  20. type Manager interface {
  21.         Plugins() map[string]Plugin
  22.         Register(name string, plugin Plugin) error
  23. }
  25. // Handler is the plugin middleware handler which wraps an existing http.Handler passed in.
  26. // Its the responsibility of the Handler to call the next http.Handler in the chain.
  27. type Handler func(http.Handler) http.Handler

How to use it

Here’s a simple example of a plugin that adds a flag and then prints the value

The plugin

Create a plugin.go file in the top level dir

  1. package main
  3. import (
  4.     "log"
  5.     "github.com/micro/cli"
  6.     "github.com/micro/micro/plugin"
  7. )
  9. func init() {
  10.     plugin.Register(plugin.NewPlugin(
  11.         plugin.WithName("example"),
  12.         plugin.WithFlag(cli.StringFlag{
  13.             Name:   "example_flag",
  14.             Usage:  "This is an example plugin flag",
  15.             EnvVar: "EXAMPLE_FLAG",
  16.             Value: "avalue",
  17.         }),
  18.         plugin.WithInit(func(ctx *cli.Context) error {
  19.             log.Println("Got value for example_flag", ctx.String("example_flag"))
  20.             return nil
  21.         }),
  22.     ))
  23. }

Building the code

Simply build micro with the plugin

  1. go build -o micro ./main.go ./plugin.go

Repository

The plugins for the toolkit can be found in github.com/micro/go-plugins/micro.