【containerd 1.0 源码分析】containerd-shime 启动流程分析

命令：

shim for container lifecycle and reconnection




USAGE:
   containerd-shim [global options] command [command options] [arguments...]


VERSION:
   v1.0.0-alpha3.m


COMMANDS:
     help, h  Shows a list of commands or help for one command


GLOBAL OPTIONS:
   --debug                      enable debug output in logs
   --namespace value, -n value  namespace that owns the task
   --socket value, -s value     abstract socket path to serve on
   --address value, -a value    grpc address back to containerd
   --help, -h                   show help
   --version, -v                print the version

 

 

 

一. containerd-shim main 函数

 

   1.1 入口目录为 cmd/containerd/main.go 中 main 函数，NewApp 使用了第三方一个命令行设置，设置名字，以及命令行启动参数，子命令等

app := cli.NewApp()
app.Name = "containerd-shim"
app.Version = version.Version
app.Usage = usage
app.Flags = []cli.Flag{
       cli.BoolFlag{
              Name:  "debug",
              Usage: "enable debug output in logs",
       },
       cli.StringFlag{
              Name:  "namespace,n",
              Usage: "namespace that owns the task",
       },
       cli.StringFlag{
              Name:  "socket,s",
              Usage: "abstract socket path to serve on",
       },
       cli.StringFlag{
              Name:  "address,a",
              Usage: "grpc address back to containerd",
       },
}
app.Before = func(context *cli.Context) error {
       if context.GlobalBool("debug") {
              logrus.SetLevel(logrus.DebugLevel)
       }
       return nil
}

 

   1.2 app.Action 主要是建立 GRPC 服务，以及创建 shim 服务

app.Action = func(context *cli.Context) error {
       // start handling signals as soon as possible so that things are properly reaped
       // or if runtime exits before we hit the handler
       signals, err := setupSignals()
       if err != nil {
              return err
       }
       path, err := os.Getwd()
       if err != nil {
              return err
       }
       server := grpc.NewServer()
       e, err := connectEvents(context.GlobalString("address"))
       if err != nil {
              return err
       }
       sv, err := shim.NewService(
              path,
              context.GlobalString("namespace"),
              &remoteEventsPublisher{client: e},
       )
       if err != nil {
              return err
       }
       logrus.Debug("registering grpc server")
       shimapi.RegisterShimServer(server, sv)
       socket := context.GlobalString("socket")
       if err := serve(server, socket); err != nil {
              return err
       }
       return handleSignals(signals, server)
}

 

   1.3 NewService 如下

// NewService returns a new shim service that can be used via GRPC
func NewService(path, namespace string, publisher events.Publisher) (*Service, error) {
       if namespace == "" {
              return nil, fmt.Errorf("shim namespace cannot be empty")
       }
       context := namespaces.WithNamespace(context.Background(), namespace)
       s := &Service{
              path:      path,
              processes: make(map[string]process),
              events:    make(chan interface{}, 4096),
              namespace: namespace,
              context:   context,
       }
       if err := s.initPlatform(); err != nil {
              return nil, errors.Wrap(err, "failed to initialized platform behavior")
       }
       go s.forward(publisher)
       return s, nil
}

 

   1.4 serve 如果没有指定 --socket 则从父继承过来

// serve serves the grpc API over a unix socket at the provided path
// this function does not block
func serve(server *grpc.Server, path string) error {
       var (
              l   net.Listener
              err error
       )
       if path == "" {
              l, err = net.FileListener(os.NewFile(3, "socket"))
              path = "[inherited from parent]"
       } else {
              l, err = net.Listen("unix", "\x00"+path)
       }
       if err != nil {
              return err
       }
       logrus.WithField("socket", path).Debug("serving api on unix socket")
       go func() {
              defer l.Close()
              if err := server.Serve(l); err != nil &&
                     !strings.Contains(err.Error(), "use of closed network connection") {
                     logrus.WithError(err).Fatal("containerd-shim: GRPC server failure")
              }
       }()
       return nil
}