【containerd 1.0 源码分析】ctr containers list 源码分析

命令：

ctr containers -h
NAME:
   ctr containers - manage containers (metadata)


USAGE:
   ctr containers command [command options] [arguments...]


COMMANDS:
     list, ls         list all tasks or those that match a filter
     delete, del, rm  delete an existing container
     label            Set and clear labels for a container.


OPTIONS:
   --help, -h  show help

 

一. ctr containers list 命令

 

    

    1.1 服务端收到 GRPC 请求

func _Containers_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
       in := new(ListContainersRequest)
       if err := dec(in); err != nil {
              return nil, err
       }
       if interceptor == nil {
              return srv.(ContainersServer).List(ctx, in)
       }
       info := &grpc.UnaryServerInfo{
              Server:     srv,
              FullMethod: "/containerd.services.containers.v1.Containers/List",
       }
       handler := func(ctx context.Context, req interface{}) (interface{}, error) {
              return srv.(ContainersServer).List(ctx, req.(*ListContainersRequest))
       }
       return interceptor(ctx, in, info, handler)
}

 

    1.2 services/containers/service.go 中 重要的函数 store.List 为实现的接口

func (s *Service) List(ctx context.Context, req *api.ListContainersRequest) (*api.ListContainersResponse, error) {
       var resp api.ListContainersResponse

       return &resp, errdefs.ToGRPC(s.withStoreView(ctx, func(ctx context.Context, store containers.Store) error {
              containers, err := store.List(ctx, req.Filters...)
              if err != nil {
                     return err
              }

              resp.Containers = containersToProto(containers)
              return nil
       }))
}

 

    1.3 根据 withStore 函数可以得到 store 为 metadata.NewContainerStore，路径 /metadata/containers.go 中，containerStore 结构体是包裹的是操作数据库

type containerStore struct {
       tx *bolt.Tx
}

func NewContainerStore(tx *bolt.Tx) containers.Store {
       return &containerStore{
              tx: tx,
       }
}

 

    1.4 List 函数中 getContainerBucket 如果为空，证明没有container 在 1.4.1 中讲解，readContainer 将数据读入到 container 中。

func (s *containerStore) List(ctx context.Context, fs ...string) ([]containers.Container, error) {
       namespace, err := namespaces.NamespaceRequired(ctx)
       
       filter, err := filters.ParseAll(fs...)

       bkt := getContainersBucket(s.tx, namespace)
       if bkt == nil {
              return nil, nil
       }

       var m []containers.Container
       if err := bkt.ForEach(func(k, v []byte) error {
              cbkt := bkt.Bucket(k)
              if cbkt == nil {
                     return nil
              }
              container := containers.Container{ID: string(k)}

              if err := readContainer(&container, cbkt); err != nil {
                     return errors.Wrap(err, "failed to read container")
              }

              if filter.Match(adaptContainer(container)) {
                     m = append(m, container)
              }
              return nil
       }); err != nil {
              return nil, err
       }

       return m, nil
}

 

    1.4.1 getContainersBucket 中 namespace 一般默认为 default，bucketKeyObjectContainers 为 contaiers，1.4.1.1 分析 bolt.Tx 结构体，数据库的有点乱，现在只知道是操作数据库就行了。尴尬！！！tx.Bucket 在 1.4.1.2 讲解

func getContainersBucket(tx *bolt.Tx, namespace string) *bolt.Bucket {
       return getBucket(tx, bucketKeyVersion, []byte(namespace), bucketKeyObjectContainers)
}

func getBucket(tx *bolt.Tx, keys ...[]byte) *bolt.Bucket {
       bkt := tx.Bucket(keys[0])

       for _, key := range keys[1:] {
              if bkt == nil {
                     break
              }
              bkt = bkt.Bucket(key)
       }

       return bkt
}

 

    1.4.1.1 结构体

type Tx struct {
       writable       bool
       managed        bool
       db             *DB
       meta           *meta
       root           Bucket
       pages          map[pgid]*page
       stats          TxStats
       commitHandlers []func()

       WriteFlag int

    Bucket 表示 key / value 对存在数据库中

// Bucket represents a collection of key/value pairs inside the database.
type Bucket struct {
       *bucket
       tx       *Tx                // the associated transaction
       buckets  map[string]*Bucket // subbucket cache
       page     *page              // inline page reference
       rootNode *node              // materialized node for the root page.
       nodes    map[pgid]*node     // node cache

       // Sets the threshold for filling nodes when they split. By default,
       // the bucket will fill to 50% but it can be useful to increase this
       // amount if you know that your write workloads are mostly append-only.
       //
       // This is non-persisted across transactions so it must be set in every Tx.
       FillPercent float64
}

 

     1.4.1.2 Bucket 函数根据名字检索，返回 Bucket 结构体

func (tx *Tx) Bucket(name []byte) *Bucket {
       return tx.root.Bucket(name)
}