docker源码3-plugin的管理

谢绝转载

序言

上篇看了plugin的存储和管理,打铁要趁热,那么看一下当docker运行时,执行plugin的相关命令是如何与PluginStore对应起来的.

注意事项:
1.本文共有四篇,每篇都有编号,编号类似1.2.1这种,其中1是文章编号,因为后面的调用关系需要去前面篇幅中找,所以我标注了这个方便寻找.

2.我是按调用过程列出代码,如果当前函数有多个地方需要讲解,比如函数1.2中有两个地方需要讲解,那么要展开的地方便是1.2.1,1.2.2这样排列.

3.链接:
第一篇:https://www.jianshu.com/p/9900ec52f2c1 (命令的调用流程)
第二篇:https://www.jianshu.com/p/db08b7d57721 (卷服务初始化)
第三篇:https://www.jianshu.com/p/bbc73f5687a2 (plugin的管理)
第四篇:https://www.jianshu.com/p/a92b1b11c8dd (卷相关命令的执行)

plugin的管理

老规矩,要看命令,先看initRouter函数:

3.1 initRouter函数

func initRouter(opts routerOptions) {
    decoder := runconfig.ContainerDecoder{}

    routers := []router.Router{
        ...
        pluginrouter.NewRouter(opts.daemon.PluginManager()),
        ...
    }
...
}

继续看NewRouter函数

3.2 NewRouter函数以及initRoutes方法

// NewRouter initializes a new plugin router
func NewRouter(b Backend) router.Router {
    r := &pluginRouter{
        backend: b,
    }
    r.initRoutes()
    return r
}
...
func (r *pluginRouter) initRoutes() {
    r.routes = []router.Route{
        router.NewGetRoute("/plugins", r.listPlugins),
        router.NewGetRoute("/plugins/{name:.*}/json", r.inspectPlugin),
        router.NewGetRoute("/plugins/privileges", r.getPrivileges),
        router.NewDeleteRoute("/plugins/{name:.*}", r.removePlugin),
        router.NewPostRoute("/plugins/{name:.*}/enable", r.enablePlugin), // PATCH?
        router.NewPostRoute("/plugins/{name:.*}/disable", r.disablePlugin),
        router.NewPostRoute("/plugins/pull", r.pullPlugin, router.WithCancel),
        router.NewPostRoute("/plugins/{name:.*}/push", r.pushPlugin, router.WithCancel),
        router.NewPostRoute("/plugins/{name:.*}/upgrade", r.upgradePlugin, router.WithCancel),
        router.NewPostRoute("/plugins/{name:.*}/set", r.setPlugin),
        router.NewPostRoute("/plugins/create", r.createPlugin),
    }
}

还是选两个代表吧,看一下createPlugin和enablePlugin的调用:

3.3 createPlugin方法和enablePlugin方法:

func (pr *pluginRouter) createPlugin(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
    ...

    if err := pr.backend.CreateFromContext(ctx, r.Body, options); err != nil {
        return err
    }
    ...
    return nil
}

func (pr *pluginRouter) enablePlugin(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
    ...

    return pr.backend.Enable(name, config)
}

根据initRoutes方法,pr.backend是opts.daemon.PluginManager():

3.4 PluginManager方法

// PluginManager returns current pluginManager associated with the daemon
func (daemon *Daemon) PluginManager() *plugin.Manager { // set up before daemon to avoid this method
    return daemon.pluginManager
}

这个方法的返回值跟我们第二篇中讲到的pluginManager就对应起来了

3.5 CreateFromContext方法

先看CreateFromContext方法:

func (pm *Manager) CreateFromContext(ctx context.Context, tarCtx io.ReadCloser, options *types.PluginCreateOptions) (err error) {
    ...
    # 上面是一系列的准备工作,直接略去看重点:
    p, err := pm.createPlugin(name, configBlobsum, []digest.Digest{rootFSBlobsum}, tmpRootFSDir, nil)
    if err != nil {
        return err
    }
    p.PluginObj.PluginReference = name

    pm.publisher.Publish(EventCreate{Plugin: p.PluginObj})
    pm.config.LogPluginEvent(p.PluginObj.ID, name, "create")

    return nil
}

• 3.5.1 createPlugin方法

上面调用到了pm.createPlugin方法:

// createPlugin creates a new plugin. take lock before calling.
func (pm *Manager) createPlugin(name string, configDigest digest.Digest, blobsums []digest.Digest, rootFSDir string, privileges *types.PluginPrivileges, opts ...CreateOpt) (p *v2.Plugin, err error) {
    ...

    # 创建plugin
    p = &v2.Plugin{
        PluginObj: types.Plugin{
            Name:   name,
            ID:     stringid.GenerateRandomID(),
            Config: config,
        },
        Config:   configDigest,
        Blobsums: blobsums,
    }
    ...

    #创建plugin对应文件夹
    pdir := filepath.Join(pm.config.Root, p.PluginObj.ID)
    if err := os.MkdirAll(pdir, 0700); err != nil {
        return nil, errors.Wrapf(err, "failed to mkdir %v", pdir)
    }

    defer func() {
        if err != nil {
            os.RemoveAll(pdir)
        }
    }()

    if err := os.Rename(rootFSDir, filepath.Join(pdir, rootFSFileName)); err != nil {
        return nil, errors.Wrap(err, "failed to rename rootfs")
    }

    if err := pm.save(p); err != nil {
        return nil, err
    }
    # 又看见我们熟悉的pm.config.Store了
    pm.config.Store.Add(p) // todo: remove

    return p, nil
}

这样新建的plugin就被保存到pm.config.Store中了. 接着看Enable方法:

3.6 Enable方法

Enable方法用来启动plugin:

// Enable activates a plugin, which implies that they are ready to be used by containers.
func (pm *Manager) Enable(refOrID string, config *types.PluginEnableConfig) error {
    # 获取plugin
    p, err := pm.config.Store.GetV2Plugin(refOrID)
    if err != nil {
        return err
    }

    c := &controller{timeoutInSecs: config.Timeout}
    if err := pm.enable(p, c, false); err != nil {
        return err
    }
    pm.publisher.Publish(EventEnable{Plugin: p.PluginObj})
    pm.config.LogPluginEvent(p.GetID(), refOrID, "enable")
    return nil
}

继续看pm.enable方法:

• 3.6.1 enable方法

func (pm *Manager) enable(p *v2.Plugin, c *controller, force bool) error {
    ...
    stdout, stderr := makeLoggerStreams(p.GetID())
    # 这里调用pm.executor.Create方法来创建一个plugin容器,这个容器只能用docker-runc命令查看
    if err := pm.executor.Create(p.GetID(), *spec, stdout, stderr); err != nil {
        if p.PluginObj.Config.PropagatedMount != "" {
            if err := mount.Unmount(propRoot); err != nil {
                logrus.Warnf("Could not unmount %s: %v", propRoot, err)
            }
        }
        return errors.WithStack(err)
    }
    return pm.pluginPostStart(p, c)
}

pm.executor在上篇讲过了,在对应的目录下找到Create方法就可以看到具体的执行过程,这里就不再看了.

总结

其他的方法就不仔细看了,串起来以后这部分代码很好理解的,当然我说的是大概流程的理解.