Merge pull request #7609 from dmcgowan/generate-ttrpc-services

Generate proto services with go-ttrpc

api/Protobuild.toml

@@ -1,5 +1,5 @@
 version = "2"
-generators = ["go", "go-grpc"]
+generators = ["go", "go-grpc", "go-ttrpc"]
 
 # Control protoc include paths. Below are usually some good defaults, but feel
 # free to try it without them if it works for your project.
@@ -18,14 +18,23 @@ generators = ["go", "go-grpc"]
 [packages]
   "google/rpc/status.proto" = "google.golang.org/genproto/googleapis/rpc/status"
 
+[parameters.go-ttrpc]
+prefix = "TTRPC"
+
 [[overrides]]
 prefixes = ["github.com/containerd/containerd/api/events"]
 generators = ["go", "go-ttrpc", "go-fieldpath"]
 
+[overrides.parameters.go-ttrpc]
+prefix = ""
+
 [[overrides]]
 prefixes = ["github.com/containerd/containerd/api/services/ttrpc/events/v1"]
 generators = ["go", "go-ttrpc"]
 
+[overrides.parameters.go-ttrpc]
+prefix = ""
+
 [[overrides]]
 # enable ttrpc and disable fieldpath and grpc for the shim
 prefixes = [
@@ -33,24 +42,21 @@ prefixes = [
 ]
 generators = ["go", "go-ttrpc"]
 
+[overrides.parameters.go-ttrpc]
+prefix = ""
+
 [[overrides]]
 prefixes = [
   "github.com/containerd/containerd/api/runtime/sandbox/v1",
 ]
 generators = ["go", "go-ttrpc", "go-grpc"]
 
-[overrides.parameters.go-ttrpc]
-prefix = "TTRPC"
-
 [[overrides]]
 prefixes = [
   "github.com/containerd/containerd/api/runtime/task/v3",
 ]
 generators = ["go", "go-ttrpc", "go-grpc"]
 
-[overrides.parameters.go-ttrpc]
-prefix = "TTRPC"
-
 # Aggregrate the API descriptors to lock down API changes.
 [[descriptors]]
 prefix = "github.com/containerd/containerd/api"

api/services/containers/v1/containers_ttrpc.pb.go

@@ -0,0 +1,174 @@
+// Code generated by protoc-gen-go-ttrpc. DO NOT EDIT.
+// source: github.com/containerd/containerd/api/services/containers/v1/containers.proto
+package containers
+
+import (
+	context "context"
+	ttrpc "github.com/containerd/ttrpc"
+	emptypb "google.golang.org/protobuf/types/known/emptypb"
+)
+
+type TTRPCContainersService interface {
+	Get(context.Context, *GetContainerRequest) (*GetContainerResponse, error)
+	List(context.Context, *ListContainersRequest) (*ListContainersResponse, error)
+	ListStream(context.Context, *ListContainersRequest, TTRPCContainers_ListStreamServer) error
+	Create(context.Context, *CreateContainerRequest) (*CreateContainerResponse, error)
+	Update(context.Context, *UpdateContainerRequest) (*UpdateContainerResponse, error)
+	Delete(context.Context, *DeleteContainerRequest) (*emptypb.Empty, error)
+}
+
+type TTRPCContainers_ListStreamServer interface {
+	Send(*ListContainerMessage) error
+	ttrpc.StreamServer
+}
+
+type ttrpccontainersListStreamServer struct {
+	ttrpc.StreamServer
+}
+
+func (x *ttrpccontainersListStreamServer) Send(m *ListContainerMessage) error {
+	return x.StreamServer.SendMsg(m)
+}
+
+func RegisterTTRPCContainersService(srv *ttrpc.Server, svc TTRPCContainersService) {
+	srv.RegisterService("containerd.services.containers.v1.Containers", &ttrpc.ServiceDesc{
+		Methods: map[string]ttrpc.Method{
+			"Get": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req GetContainerRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Get(ctx, &req)
+			},
+			"List": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req ListContainersRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.List(ctx, &req)
+			},
+			"Create": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req CreateContainerRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Create(ctx, &req)
+			},
+			"Update": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req UpdateContainerRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Update(ctx, &req)
+			},
+			"Delete": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req DeleteContainerRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Delete(ctx, &req)
+			},
+		},
+		Streams: map[string]ttrpc.Stream{
+			"ListStream": {
+				Handler: func(ctx context.Context, stream ttrpc.StreamServer) (interface{}, error) {
+					m := new(ListContainersRequest)
+					if err := stream.RecvMsg(m); err != nil {
+						return nil, err
+					}
+					return nil, svc.ListStream(ctx, m, &ttrpccontainersListStreamServer{stream})
+				},
+				StreamingClient: false,
+				StreamingServer: true,
+			},
+		},
+	})
+}
+
+type TTRPCContainersClient interface {
+	Get(context.Context, *GetContainerRequest) (*GetContainerResponse, error)
+	List(context.Context, *ListContainersRequest) (*ListContainersResponse, error)
+	ListStream(context.Context, *ListContainersRequest) (TTRPCContainers_ListStreamClient, error)
+	Create(context.Context, *CreateContainerRequest) (*CreateContainerResponse, error)
+	Update(context.Context, *UpdateContainerRequest) (*UpdateContainerResponse, error)
+	Delete(context.Context, *DeleteContainerRequest) (*emptypb.Empty, error)
+}
+
+type ttrpccontainersClient struct {
+	client *ttrpc.Client
+}
+
+func NewTTRPCContainersClient(client *ttrpc.Client) TTRPCContainersClient {
+	return &ttrpccontainersClient{
+		client: client,
+	}
+}
+
+func (c *ttrpccontainersClient) Get(ctx context.Context, req *GetContainerRequest) (*GetContainerResponse, error) {
+	var resp GetContainerResponse
+	if err := c.client.Call(ctx, "containerd.services.containers.v1.Containers", "Get", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpccontainersClient) List(ctx context.Context, req *ListContainersRequest) (*ListContainersResponse, error) {
+	var resp ListContainersResponse
+	if err := c.client.Call(ctx, "containerd.services.containers.v1.Containers", "List", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpccontainersClient) ListStream(ctx context.Context, req *ListContainersRequest) (TTRPCContainers_ListStreamClient, error) {
+	stream, err := c.client.NewStream(ctx, &ttrpc.StreamDesc{
+		StreamingClient: false,
+		StreamingServer: true,
+	}, "containerd.services.containers.v1.Containers", "ListStream", req)
+	if err != nil {
+		return nil, err
+	}
+	x := &ttrpccontainersListStreamClient{stream}
+	return x, nil
+}
+
+type TTRPCContainers_ListStreamClient interface {
+	Recv() (*ListContainerMessage, error)
+	ttrpc.ClientStream
+}
+
+type ttrpccontainersListStreamClient struct {
+	ttrpc.ClientStream
+}
+
+func (x *ttrpccontainersListStreamClient) Recv() (*ListContainerMessage, error) {
+	m := new(ListContainerMessage)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *ttrpccontainersClient) Create(ctx context.Context, req *CreateContainerRequest) (*CreateContainerResponse, error) {
+	var resp CreateContainerResponse
+	if err := c.client.Call(ctx, "containerd.services.containers.v1.Containers", "Create", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpccontainersClient) Update(ctx context.Context, req *UpdateContainerRequest) (*UpdateContainerResponse, error) {
+	var resp UpdateContainerResponse
+	if err := c.client.Call(ctx, "containerd.services.containers.v1.Containers", "Update", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpccontainersClient) Delete(ctx context.Context, req *DeleteContainerRequest) (*emptypb.Empty, error) {
+	var resp emptypb.Empty
+	if err := c.client.Call(ctx, "containerd.services.containers.v1.Containers", "Delete", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}

api/services/content/v1/content_ttrpc.pb.go

@@ -0,0 +1,311 @@
+// Code generated by protoc-gen-go-ttrpc. DO NOT EDIT.
+// source: github.com/containerd/containerd/api/services/content/v1/content.proto
+package content
+
+import (
+	context "context"
+	ttrpc "github.com/containerd/ttrpc"
+	emptypb "google.golang.org/protobuf/types/known/emptypb"
+)
+
+type TTRPCContentService interface {
+	Info(context.Context, *InfoRequest) (*InfoResponse, error)
+	Update(context.Context, *UpdateRequest) (*UpdateResponse, error)
+	List(context.Context, *ListContentRequest, TTRPCContent_ListServer) error
+	Delete(context.Context, *DeleteContentRequest) (*emptypb.Empty, error)
+	Read(context.Context, *ReadContentRequest, TTRPCContent_ReadServer) error
+	Status(context.Context, *StatusRequest) (*StatusResponse, error)
+	ListStatuses(context.Context, *ListStatusesRequest) (*ListStatusesResponse, error)
+	Write(context.Context, TTRPCContent_WriteServer) error
+	Abort(context.Context, *AbortRequest) (*emptypb.Empty, error)
+}
+
+type TTRPCContent_ListServer interface {
+	Send(*ListContentResponse) error
+	ttrpc.StreamServer
+}
+
+type ttrpccontentListServer struct {
+	ttrpc.StreamServer
+}
+
+func (x *ttrpccontentListServer) Send(m *ListContentResponse) error {
+	return x.StreamServer.SendMsg(m)
+}
+
+type TTRPCContent_ReadServer interface {
+	Send(*ReadContentResponse) error
+	ttrpc.StreamServer
+}
+
+type ttrpccontentReadServer struct {
+	ttrpc.StreamServer
+}
+
+func (x *ttrpccontentReadServer) Send(m *ReadContentResponse) error {
+	return x.StreamServer.SendMsg(m)
+}
+
+type TTRPCContent_WriteServer interface {
+	Send(*WriteContentResponse) error
+	Recv() (*WriteContentRequest, error)
+	ttrpc.StreamServer
+}
+
+type ttrpccontentWriteServer struct {
+	ttrpc.StreamServer
+}
+
+func (x *ttrpccontentWriteServer) Send(m *WriteContentResponse) error {
+	return x.StreamServer.SendMsg(m)
+}
+
+func (x *ttrpccontentWriteServer) Recv() (*WriteContentRequest, error) {
+	m := new(WriteContentRequest)
+	if err := x.StreamServer.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func RegisterTTRPCContentService(srv *ttrpc.Server, svc TTRPCContentService) {
+	srv.RegisterService("containerd.services.content.v1.Content", &ttrpc.ServiceDesc{
+		Methods: map[string]ttrpc.Method{
+			"Info": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req InfoRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Info(ctx, &req)
+			},
+			"Update": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req UpdateRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Update(ctx, &req)
+			},
+			"Delete": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req DeleteContentRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Delete(ctx, &req)
+			},
+			"Status": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req StatusRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Status(ctx, &req)
+			},
+			"ListStatuses": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req ListStatusesRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.ListStatuses(ctx, &req)
+			},
+			"Abort": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req AbortRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Abort(ctx, &req)
+			},
+		},
+		Streams: map[string]ttrpc.Stream{
+			"List": {
+				Handler: func(ctx context.Context, stream ttrpc.StreamServer) (interface{}, error) {
+					m := new(ListContentRequest)
+					if err := stream.RecvMsg(m); err != nil {
+						return nil, err
+					}
+					return nil, svc.List(ctx, m, &ttrpccontentListServer{stream})
+				},
+				StreamingClient: false,
+				StreamingServer: true,
+			},
+			"Read": {
+				Handler: func(ctx context.Context, stream ttrpc.StreamServer) (interface{}, error) {
+					m := new(ReadContentRequest)
+					if err := stream.RecvMsg(m); err != nil {
+						return nil, err
+					}
+					return nil, svc.Read(ctx, m, &ttrpccontentReadServer{stream})
+				},
+				StreamingClient: false,
+				StreamingServer: true,
+			},
+			"Write": {
+				Handler: func(ctx context.Context, stream ttrpc.StreamServer) (interface{}, error) {
+					return nil, svc.Write(ctx, &ttrpccontentWriteServer{stream})
+				},
+				StreamingClient: true,
+				StreamingServer: true,
+			},
+		},
+	})
+}
+
+type TTRPCContentClient interface {
+	Info(context.Context, *InfoRequest) (*InfoResponse, error)
+	Update(context.Context, *UpdateRequest) (*UpdateResponse, error)
+	List(context.Context, *ListContentRequest) (TTRPCContent_ListClient, error)
+	Delete(context.Context, *DeleteContentRequest) (*emptypb.Empty, error)
+	Read(context.Context, *ReadContentRequest) (TTRPCContent_ReadClient, error)
+	Status(context.Context, *StatusRequest) (*StatusResponse, error)
+	ListStatuses(context.Context, *ListStatusesRequest) (*ListStatusesResponse, error)
+	Write(context.Context) (TTRPCContent_WriteClient, error)
+	Abort(context.Context, *AbortRequest) (*emptypb.Empty, error)
+}
+
+type ttrpccontentClient struct {
+	client *ttrpc.Client
+}
+
+func NewTTRPCContentClient(client *ttrpc.Client) TTRPCContentClient {
+	return &ttrpccontentClient{
+		client: client,
+	}
+}
+
+func (c *ttrpccontentClient) Info(ctx context.Context, req *InfoRequest) (*InfoResponse, error) {
+	var resp InfoResponse
+	if err := c.client.Call(ctx, "containerd.services.content.v1.Content", "Info", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpccontentClient) Update(ctx context.Context, req *UpdateRequest) (*UpdateResponse, error) {
+	var resp UpdateResponse
+	if err := c.client.Call(ctx, "containerd.services.content.v1.Content", "Update", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpccontentClient) List(ctx context.Context, req *ListContentRequest) (TTRPCContent_ListClient, error) {
+	stream, err := c.client.NewStream(ctx, &ttrpc.StreamDesc{
+		StreamingClient: false,
+		StreamingServer: true,
+	}, "containerd.services.content.v1.Content", "List", req)
+	if err != nil {
+		return nil, err
+	}
+	x := &ttrpccontentListClient{stream}
+	return x, nil
+}
+
+type TTRPCContent_ListClient interface {
+	Recv() (*ListContentResponse, error)
+	ttrpc.ClientStream
+}
+
+type ttrpccontentListClient struct {
+	ttrpc.ClientStream
+}
+
+func (x *ttrpccontentListClient) Recv() (*ListContentResponse, error) {
+	m := new(ListContentResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *ttrpccontentClient) Delete(ctx context.Context, req *DeleteContentRequest) (*emptypb.Empty, error) {
+	var resp emptypb.Empty
+	if err := c.client.Call(ctx, "containerd.services.content.v1.Content", "Delete", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpccontentClient) Read(ctx context.Context, req *ReadContentRequest) (TTRPCContent_ReadClient, error) {
+	stream, err := c.client.NewStream(ctx, &ttrpc.StreamDesc{
+		StreamingClient: false,
+		StreamingServer: true,
+	}, "containerd.services.content.v1.Content", "Read", req)
+	if err != nil {
+		return nil, err
+	}
+	x := &ttrpccontentReadClient{stream}
+	return x, nil
+}
+
+type TTRPCContent_ReadClient interface {
+	Recv() (*ReadContentResponse, error)
+	ttrpc.ClientStream
+}
+
+type ttrpccontentReadClient struct {
+	ttrpc.ClientStream
+}
+
+func (x *ttrpccontentReadClient) Recv() (*ReadContentResponse, error) {
+	m := new(ReadContentResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *ttrpccontentClient) Status(ctx context.Context, req *StatusRequest) (*StatusResponse, error) {
+	var resp StatusResponse
+	if err := c.client.Call(ctx, "containerd.services.content.v1.Content", "Status", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpccontentClient) ListStatuses(ctx context.Context, req *ListStatusesRequest) (*ListStatusesResponse, error) {
+	var resp ListStatusesResponse
+	if err := c.client.Call(ctx, "containerd.services.content.v1.Content", "ListStatuses", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpccontentClient) Write(ctx context.Context) (TTRPCContent_WriteClient, error) {
+	stream, err := c.client.NewStream(ctx, &ttrpc.StreamDesc{
+		StreamingClient: true,
+		StreamingServer: true,
+	}, "containerd.services.content.v1.Content", "Write", nil)
+	if err != nil {
+		return nil, err
+	}
+	x := &ttrpccontentWriteClient{stream}
+	return x, nil
+}
+
+type TTRPCContent_WriteClient interface {
+	Send(*WriteContentRequest) error
+	Recv() (*WriteContentResponse, error)
+	ttrpc.ClientStream
+}
+
+type ttrpccontentWriteClient struct {
+	ttrpc.ClientStream
+}
+
+func (x *ttrpccontentWriteClient) Send(m *WriteContentRequest) error {
+	return x.ClientStream.SendMsg(m)
+}
+
+func (x *ttrpccontentWriteClient) Recv() (*WriteContentResponse, error) {
+	m := new(WriteContentResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *ttrpccontentClient) Abort(ctx context.Context, req *AbortRequest) (*emptypb.Empty, error) {
+	var resp emptypb.Empty
+	if err := c.client.Call(ctx, "containerd.services.content.v1.Content", "Abort", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}

api/services/diff/v1/diff_ttrpc.pb.go

@@ -0,0 +1,60 @@
+// Code generated by protoc-gen-go-ttrpc. DO NOT EDIT.
+// source: github.com/containerd/containerd/api/services/diff/v1/diff.proto
+package diff
+
+import (
+	context "context"
+	ttrpc "github.com/containerd/ttrpc"
+)
+
+type TTRPCDiffService interface {
+	Apply(context.Context, *ApplyRequest) (*ApplyResponse, error)
+	Diff(context.Context, *DiffRequest) (*DiffResponse, error)
+}
+
+func RegisterTTRPCDiffService(srv *ttrpc.Server, svc TTRPCDiffService) {
+	srv.RegisterService("containerd.services.diff.v1.Diff", &ttrpc.ServiceDesc{
+		Methods: map[string]ttrpc.Method{
+			"Apply": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req ApplyRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Apply(ctx, &req)
+			},
+			"Diff": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req DiffRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Diff(ctx, &req)
+			},
+		},
+	})
+}
+
+type ttrpcdiffClient struct {
+	client *ttrpc.Client
+}
+
+func NewTTRPCDiffClient(client *ttrpc.Client) TTRPCDiffService {
+	return &ttrpcdiffClient{
+		client: client,
+	}
+}
+
+func (c *ttrpcdiffClient) Apply(ctx context.Context, req *ApplyRequest) (*ApplyResponse, error) {
+	var resp ApplyResponse
+	if err := c.client.Call(ctx, "containerd.services.diff.v1.Diff", "Apply", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpcdiffClient) Diff(ctx context.Context, req *DiffRequest) (*DiffResponse, error) {
+	var resp DiffResponse
+	if err := c.client.Call(ctx, "containerd.services.diff.v1.Diff", "Diff", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}

api/services/events/v1/events_ttrpc.pb.go

@@ -0,0 +1,124 @@
+// Code generated by protoc-gen-go-ttrpc. DO NOT EDIT.
+// source: github.com/containerd/containerd/api/services/events/v1/events.proto
+package events
+
+import (
+	context "context"
+	types "github.com/containerd/containerd/v2/api/types"
+	ttrpc "github.com/containerd/ttrpc"
+	emptypb "google.golang.org/protobuf/types/known/emptypb"
+)
+
+type TTRPCEventsService interface {
+	Publish(context.Context, *PublishRequest) (*emptypb.Empty, error)
+	Forward(context.Context, *ForwardRequest) (*emptypb.Empty, error)
+	Subscribe(context.Context, *SubscribeRequest, TTRPCEvents_SubscribeServer) error
+}
+
+type TTRPCEvents_SubscribeServer interface {
+	Send(*types.Envelope) error
+	ttrpc.StreamServer
+}
+
+type ttrpceventsSubscribeServer struct {
+	ttrpc.StreamServer
+}
+
+func (x *ttrpceventsSubscribeServer) Send(m *types.Envelope) error {
+	return x.StreamServer.SendMsg(m)
+}
+
+func RegisterTTRPCEventsService(srv *ttrpc.Server, svc TTRPCEventsService) {
+	srv.RegisterService("containerd.services.events.v1.Events", &ttrpc.ServiceDesc{
+		Methods: map[string]ttrpc.Method{
+			"Publish": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req PublishRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Publish(ctx, &req)
+			},
+			"Forward": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req ForwardRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Forward(ctx, &req)
+			},
+		},
+		Streams: map[string]ttrpc.Stream{
+			"Subscribe": {
+				Handler: func(ctx context.Context, stream ttrpc.StreamServer) (interface{}, error) {
+					m := new(SubscribeRequest)
+					if err := stream.RecvMsg(m); err != nil {
+						return nil, err
+					}
+					return nil, svc.Subscribe(ctx, m, &ttrpceventsSubscribeServer{stream})
+				},
+				StreamingClient: false,
+				StreamingServer: true,
+			},
+		},
+	})
+}
+
+type TTRPCEventsClient interface {
+	Publish(context.Context, *PublishRequest) (*emptypb.Empty, error)
+	Forward(context.Context, *ForwardRequest) (*emptypb.Empty, error)
+	Subscribe(context.Context, *SubscribeRequest) (TTRPCEvents_SubscribeClient, error)
+}
+
+type ttrpceventsClient struct {
+	client *ttrpc.Client
+}
+
+func NewTTRPCEventsClient(client *ttrpc.Client) TTRPCEventsClient {
+	return &ttrpceventsClient{
+		client: client,
+	}
+}
+
+func (c *ttrpceventsClient) Publish(ctx context.Context, req *PublishRequest) (*emptypb.Empty, error) {
+	var resp emptypb.Empty
+	if err := c.client.Call(ctx, "containerd.services.events.v1.Events", "Publish", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpceventsClient) Forward(ctx context.Context, req *ForwardRequest) (*emptypb.Empty, error) {
+	var resp emptypb.Empty
+	if err := c.client.Call(ctx, "containerd.services.events.v1.Events", "Forward", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpceventsClient) Subscribe(ctx context.Context, req *SubscribeRequest) (TTRPCEvents_SubscribeClient, error) {
+	stream, err := c.client.NewStream(ctx, &ttrpc.StreamDesc{
+		StreamingClient: false,
+		StreamingServer: true,
+	}, "containerd.services.events.v1.Events", "Subscribe", req)
+	if err != nil {
+		return nil, err
+	}
+	x := &ttrpceventsSubscribeClient{stream}
+	return x, nil
+}
+
+type TTRPCEvents_SubscribeClient interface {
+	Recv() (*types.Envelope, error)
+	ttrpc.ClientStream
+}
+
+type ttrpceventsSubscribeClient struct {
+	ttrpc.ClientStream
+}
+
+func (x *ttrpceventsSubscribeClient) Recv() (*types.Envelope, error) {
+	m := new(types.Envelope)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}

api/services/images/v1/images_ttrpc.pb.go

@@ -0,0 +1,109 @@
+// Code generated by protoc-gen-go-ttrpc. DO NOT EDIT.
+// source: github.com/containerd/containerd/api/services/images/v1/images.proto
+package images
+
+import (
+	context "context"
+	ttrpc "github.com/containerd/ttrpc"
+	emptypb "google.golang.org/protobuf/types/known/emptypb"
+)
+
+type TTRPCImagesService interface {
+	Get(context.Context, *GetImageRequest) (*GetImageResponse, error)
+	List(context.Context, *ListImagesRequest) (*ListImagesResponse, error)
+	Create(context.Context, *CreateImageRequest) (*CreateImageResponse, error)
+	Update(context.Context, *UpdateImageRequest) (*UpdateImageResponse, error)
+	Delete(context.Context, *DeleteImageRequest) (*emptypb.Empty, error)
+}
+
+func RegisterTTRPCImagesService(srv *ttrpc.Server, svc TTRPCImagesService) {
+	srv.RegisterService("containerd.services.images.v1.Images", &ttrpc.ServiceDesc{
+		Methods: map[string]ttrpc.Method{
+			"Get": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req GetImageRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Get(ctx, &req)
+			},
+			"List": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req ListImagesRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.List(ctx, &req)
+			},
+			"Create": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req CreateImageRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Create(ctx, &req)
+			},
+			"Update": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req UpdateImageRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Update(ctx, &req)
+			},
+			"Delete": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req DeleteImageRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Delete(ctx, &req)
+			},
+		},
+	})
+}
+
+type ttrpcimagesClient struct {
+	client *ttrpc.Client
+}
+
+func NewTTRPCImagesClient(client *ttrpc.Client) TTRPCImagesService {
+	return &ttrpcimagesClient{
+		client: client,
+	}
+}
+
+func (c *ttrpcimagesClient) Get(ctx context.Context, req *GetImageRequest) (*GetImageResponse, error) {
+	var resp GetImageResponse
+	if err := c.client.Call(ctx, "containerd.services.images.v1.Images", "Get", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpcimagesClient) List(ctx context.Context, req *ListImagesRequest) (*ListImagesResponse, error) {
+	var resp ListImagesResponse
+	if err := c.client.Call(ctx, "containerd.services.images.v1.Images", "List", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpcimagesClient) Create(ctx context.Context, req *CreateImageRequest) (*CreateImageResponse, error) {
+	var resp CreateImageResponse
+	if err := c.client.Call(ctx, "containerd.services.images.v1.Images", "Create", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpcimagesClient) Update(ctx context.Context, req *UpdateImageRequest) (*UpdateImageResponse, error) {
+	var resp UpdateImageResponse
+	if err := c.client.Call(ctx, "containerd.services.images.v1.Images", "Update", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpcimagesClient) Delete(ctx context.Context, req *DeleteImageRequest) (*emptypb.Empty, error) {
+	var resp emptypb.Empty
+	if err := c.client.Call(ctx, "containerd.services.images.v1.Images", "Delete", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}

api/services/introspection/v1/introspection_ttrpc.pb.go

@@ -0,0 +1,77 @@
+// Code generated by protoc-gen-go-ttrpc. DO NOT EDIT.
+// source: github.com/containerd/containerd/api/services/introspection/v1/introspection.proto
+package introspection
+
+import (
+	context "context"
+	ttrpc "github.com/containerd/ttrpc"
+	emptypb "google.golang.org/protobuf/types/known/emptypb"
+)
+
+type TTRPCIntrospectionService interface {
+	Plugins(context.Context, *PluginsRequest) (*PluginsResponse, error)
+	Server(context.Context, *emptypb.Empty) (*ServerResponse, error)
+	PluginInfo(context.Context, *PluginInfoRequest) (*PluginInfoResponse, error)
+}
+
+func RegisterTTRPCIntrospectionService(srv *ttrpc.Server, svc TTRPCIntrospectionService) {
+	srv.RegisterService("containerd.services.introspection.v1.Introspection", &ttrpc.ServiceDesc{
+		Methods: map[string]ttrpc.Method{
+			"Plugins": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req PluginsRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Plugins(ctx, &req)
+			},
+			"Server": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req emptypb.Empty
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Server(ctx, &req)
+			},
+			"PluginInfo": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req PluginInfoRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.PluginInfo(ctx, &req)
+			},
+		},
+	})
+}
+
+type ttrpcintrospectionClient struct {
+	client *ttrpc.Client
+}
+
+func NewTTRPCIntrospectionClient(client *ttrpc.Client) TTRPCIntrospectionService {
+	return &ttrpcintrospectionClient{
+		client: client,
+	}
+}
+
+func (c *ttrpcintrospectionClient) Plugins(ctx context.Context, req *PluginsRequest) (*PluginsResponse, error) {
+	var resp PluginsResponse
+	if err := c.client.Call(ctx, "containerd.services.introspection.v1.Introspection", "Plugins", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpcintrospectionClient) Server(ctx context.Context, req *emptypb.Empty) (*ServerResponse, error) {
+	var resp ServerResponse
+	if err := c.client.Call(ctx, "containerd.services.introspection.v1.Introspection", "Server", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpcintrospectionClient) PluginInfo(ctx context.Context, req *PluginInfoRequest) (*PluginInfoResponse, error) {
+	var resp PluginInfoResponse
+	if err := c.client.Call(ctx, "containerd.services.introspection.v1.Introspection", "PluginInfo", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}

api/services/leases/v1/leases_ttrpc.pb.go

@@ -0,0 +1,125 @@
+// Code generated by protoc-gen-go-ttrpc. DO NOT EDIT.
+// source: github.com/containerd/containerd/api/services/leases/v1/leases.proto
+package leases
+
+import (
+	context "context"
+	ttrpc "github.com/containerd/ttrpc"
+	emptypb "google.golang.org/protobuf/types/known/emptypb"
+)
+
+type TTRPCLeasesService interface {
+	Create(context.Context, *CreateRequest) (*CreateResponse, error)
+	Delete(context.Context, *DeleteRequest) (*emptypb.Empty, error)
+	List(context.Context, *ListRequest) (*ListResponse, error)
+	AddResource(context.Context, *AddResourceRequest) (*emptypb.Empty, error)
+	DeleteResource(context.Context, *DeleteResourceRequest) (*emptypb.Empty, error)
+	ListResources(context.Context, *ListResourcesRequest) (*ListResourcesResponse, error)
+}
+
+func RegisterTTRPCLeasesService(srv *ttrpc.Server, svc TTRPCLeasesService) {
+	srv.RegisterService("containerd.services.leases.v1.Leases", &ttrpc.ServiceDesc{
+		Methods: map[string]ttrpc.Method{
+			"Create": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req CreateRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Create(ctx, &req)
+			},
+			"Delete": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req DeleteRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Delete(ctx, &req)
+			},
+			"List": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req ListRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.List(ctx, &req)
+			},
+			"AddResource": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req AddResourceRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.AddResource(ctx, &req)
+			},
+			"DeleteResource": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req DeleteResourceRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.DeleteResource(ctx, &req)
+			},
+			"ListResources": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req ListResourcesRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.ListResources(ctx, &req)
+			},
+		},
+	})
+}
+
+type ttrpcleasesClient struct {
+	client *ttrpc.Client
+}
+
+func NewTTRPCLeasesClient(client *ttrpc.Client) TTRPCLeasesService {
+	return &ttrpcleasesClient{
+		client: client,
+	}
+}
+
+func (c *ttrpcleasesClient) Create(ctx context.Context, req *CreateRequest) (*CreateResponse, error) {
+	var resp CreateResponse
+	if err := c.client.Call(ctx, "containerd.services.leases.v1.Leases", "Create", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpcleasesClient) Delete(ctx context.Context, req *DeleteRequest) (*emptypb.Empty, error) {
+	var resp emptypb.Empty
+	if err := c.client.Call(ctx, "containerd.services.leases.v1.Leases", "Delete", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpcleasesClient) List(ctx context.Context, req *ListRequest) (*ListResponse, error) {
+	var resp ListResponse
+	if err := c.client.Call(ctx, "containerd.services.leases.v1.Leases", "List", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpcleasesClient) AddResource(ctx context.Context, req *AddResourceRequest) (*emptypb.Empty, error) {
+	var resp emptypb.Empty
+	if err := c.client.Call(ctx, "containerd.services.leases.v1.Leases", "AddResource", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpcleasesClient) DeleteResource(ctx context.Context, req *DeleteResourceRequest) (*emptypb.Empty, error) {
+	var resp emptypb.Empty
+	if err := c.client.Call(ctx, "containerd.services.leases.v1.Leases", "DeleteResource", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpcleasesClient) ListResources(ctx context.Context, req *ListResourcesRequest) (*ListResourcesResponse, error) {
+	var resp ListResourcesResponse
+	if err := c.client.Call(ctx, "containerd.services.leases.v1.Leases", "ListResources", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}

api/services/namespaces/v1/namespace_ttrpc.pb.go

@@ -0,0 +1,109 @@
+// Code generated by protoc-gen-go-ttrpc. DO NOT EDIT.
+// source: github.com/containerd/containerd/api/services/namespaces/v1/namespace.proto
+package namespaces
+
+import (
+	context "context"
+	ttrpc "github.com/containerd/ttrpc"
+	emptypb "google.golang.org/protobuf/types/known/emptypb"
+)
+
+type TTRPCNamespacesService interface {
+	Get(context.Context, *GetNamespaceRequest) (*GetNamespaceResponse, error)
+	List(context.Context, *ListNamespacesRequest) (*ListNamespacesResponse, error)
+	Create(context.Context, *CreateNamespaceRequest) (*CreateNamespaceResponse, error)
+	Update(context.Context, *UpdateNamespaceRequest) (*UpdateNamespaceResponse, error)
+	Delete(context.Context, *DeleteNamespaceRequest) (*emptypb.Empty, error)
+}
+
+func RegisterTTRPCNamespacesService(srv *ttrpc.Server, svc TTRPCNamespacesService) {
+	srv.RegisterService("containerd.services.namespaces.v1.Namespaces", &ttrpc.ServiceDesc{
+		Methods: map[string]ttrpc.Method{
+			"Get": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req GetNamespaceRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Get(ctx, &req)
+			},
+			"List": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req ListNamespacesRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.List(ctx, &req)
+			},
+			"Create": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req CreateNamespaceRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Create(ctx, &req)
+			},
+			"Update": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req UpdateNamespaceRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Update(ctx, &req)
+			},
+			"Delete": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req DeleteNamespaceRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Delete(ctx, &req)
+			},
+		},
+	})
+}
+
+type ttrpcnamespacesClient struct {
+	client *ttrpc.Client
+}
+
+func NewTTRPCNamespacesClient(client *ttrpc.Client) TTRPCNamespacesService {
+	return &ttrpcnamespacesClient{
+		client: client,
+	}
+}
+
+func (c *ttrpcnamespacesClient) Get(ctx context.Context, req *GetNamespaceRequest) (*GetNamespaceResponse, error) {
+	var resp GetNamespaceResponse
+	if err := c.client.Call(ctx, "containerd.services.namespaces.v1.Namespaces", "Get", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpcnamespacesClient) List(ctx context.Context, req *ListNamespacesRequest) (*ListNamespacesResponse, error) {
+	var resp ListNamespacesResponse
+	if err := c.client.Call(ctx, "containerd.services.namespaces.v1.Namespaces", "List", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpcnamespacesClient) Create(ctx context.Context, req *CreateNamespaceRequest) (*CreateNamespaceResponse, error) {
+	var resp CreateNamespaceResponse
+	if err := c.client.Call(ctx, "containerd.services.namespaces.v1.Namespaces", "Create", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpcnamespacesClient) Update(ctx context.Context, req *UpdateNamespaceRequest) (*UpdateNamespaceResponse, error) {
+	var resp UpdateNamespaceResponse
+	if err := c.client.Call(ctx, "containerd.services.namespaces.v1.Namespaces", "Update", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpcnamespacesClient) Delete(ctx context.Context, req *DeleteNamespaceRequest) (*emptypb.Empty, error) {
+	var resp emptypb.Empty
+	if err := c.client.Call(ctx, "containerd.services.namespaces.v1.Namespaces", "Delete", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}

api/services/sandbox/v1/sandbox_ttrpc.pb.go

@@ -0,0 +1,256 @@
+// Code generated by protoc-gen-go-ttrpc. DO NOT EDIT.
+// source: github.com/containerd/containerd/api/services/sandbox/v1/sandbox.proto
+package sandbox
+
+import (
+	context "context"
+	ttrpc "github.com/containerd/ttrpc"
+)
+
+type TTRPCStoreService interface {
+	Create(context.Context, *StoreCreateRequest) (*StoreCreateResponse, error)
+	Update(context.Context, *StoreUpdateRequest) (*StoreUpdateResponse, error)
+	Delete(context.Context, *StoreDeleteRequest) (*StoreDeleteResponse, error)
+	List(context.Context, *StoreListRequest) (*StoreListResponse, error)
+	Get(context.Context, *StoreGetRequest) (*StoreGetResponse, error)
+}
+
+func RegisterTTRPCStoreService(srv *ttrpc.Server, svc TTRPCStoreService) {
+	srv.RegisterService("containerd.services.sandbox.v1.Store", &ttrpc.ServiceDesc{
+		Methods: map[string]ttrpc.Method{
+			"Create": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req StoreCreateRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Create(ctx, &req)
+			},
+			"Update": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req StoreUpdateRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Update(ctx, &req)
+			},
+			"Delete": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req StoreDeleteRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Delete(ctx, &req)
+			},
+			"List": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req StoreListRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.List(ctx, &req)
+			},
+			"Get": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req StoreGetRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Get(ctx, &req)
+			},
+		},
+	})
+}
+
+type ttrpcstoreClient struct {
+	client *ttrpc.Client
+}
+
+func NewTTRPCStoreClient(client *ttrpc.Client) TTRPCStoreService {
+	return &ttrpcstoreClient{
+		client: client,
+	}
+}
+
+func (c *ttrpcstoreClient) Create(ctx context.Context, req *StoreCreateRequest) (*StoreCreateResponse, error) {
+	var resp StoreCreateResponse
+	if err := c.client.Call(ctx, "containerd.services.sandbox.v1.Store", "Create", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpcstoreClient) Update(ctx context.Context, req *StoreUpdateRequest) (*StoreUpdateResponse, error) {
+	var resp StoreUpdateResponse
+	if err := c.client.Call(ctx, "containerd.services.sandbox.v1.Store", "Update", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpcstoreClient) Delete(ctx context.Context, req *StoreDeleteRequest) (*StoreDeleteResponse, error) {
+	var resp StoreDeleteResponse
+	if err := c.client.Call(ctx, "containerd.services.sandbox.v1.Store", "Delete", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpcstoreClient) List(ctx context.Context, req *StoreListRequest) (*StoreListResponse, error) {
+	var resp StoreListResponse
+	if err := c.client.Call(ctx, "containerd.services.sandbox.v1.Store", "List", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpcstoreClient) Get(ctx context.Context, req *StoreGetRequest) (*StoreGetResponse, error) {
+	var resp StoreGetResponse
+	if err := c.client.Call(ctx, "containerd.services.sandbox.v1.Store", "Get", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+type TTRPCControllerService interface {
+	Create(context.Context, *ControllerCreateRequest) (*ControllerCreateResponse, error)
+	Start(context.Context, *ControllerStartRequest) (*ControllerStartResponse, error)
+	Platform(context.Context, *ControllerPlatformRequest) (*ControllerPlatformResponse, error)
+	Stop(context.Context, *ControllerStopRequest) (*ControllerStopResponse, error)
+	Wait(context.Context, *ControllerWaitRequest) (*ControllerWaitResponse, error)
+	Status(context.Context, *ControllerStatusRequest) (*ControllerStatusResponse, error)
+	Shutdown(context.Context, *ControllerShutdownRequest) (*ControllerShutdownResponse, error)
+	Metrics(context.Context, *ControllerMetricsRequest) (*ControllerMetricsResponse, error)
+}
+
+func RegisterTTRPCControllerService(srv *ttrpc.Server, svc TTRPCControllerService) {
+	srv.RegisterService("containerd.services.sandbox.v1.Controller", &ttrpc.ServiceDesc{
+		Methods: map[string]ttrpc.Method{
+			"Create": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req ControllerCreateRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Create(ctx, &req)
+			},
+			"Start": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req ControllerStartRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Start(ctx, &req)
+			},
+			"Platform": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req ControllerPlatformRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Platform(ctx, &req)
+			},
+			"Stop": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req ControllerStopRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Stop(ctx, &req)
+			},
+			"Wait": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req ControllerWaitRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Wait(ctx, &req)
+			},
+			"Status": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req ControllerStatusRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Status(ctx, &req)
+			},
+			"Shutdown": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req ControllerShutdownRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Shutdown(ctx, &req)
+			},
+			"Metrics": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req ControllerMetricsRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Metrics(ctx, &req)
+			},
+		},
+	})
+}
+
+type ttrpccontrollerClient struct {
+	client *ttrpc.Client
+}
+
+func NewTTRPCControllerClient(client *ttrpc.Client) TTRPCControllerService {
+	return &ttrpccontrollerClient{
+		client: client,
+	}
+}
+
+func (c *ttrpccontrollerClient) Create(ctx context.Context, req *ControllerCreateRequest) (*ControllerCreateResponse, error) {
+	var resp ControllerCreateResponse
+	if err := c.client.Call(ctx, "containerd.services.sandbox.v1.Controller", "Create", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpccontrollerClient) Start(ctx context.Context, req *ControllerStartRequest) (*ControllerStartResponse, error) {
+	var resp ControllerStartResponse
+	if err := c.client.Call(ctx, "containerd.services.sandbox.v1.Controller", "Start", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpccontrollerClient) Platform(ctx context.Context, req *ControllerPlatformRequest) (*ControllerPlatformResponse, error) {
+	var resp ControllerPlatformResponse
+	if err := c.client.Call(ctx, "containerd.services.sandbox.v1.Controller", "Platform", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpccontrollerClient) Stop(ctx context.Context, req *ControllerStopRequest) (*ControllerStopResponse, error) {
+	var resp ControllerStopResponse
+	if err := c.client.Call(ctx, "containerd.services.sandbox.v1.Controller", "Stop", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpccontrollerClient) Wait(ctx context.Context, req *ControllerWaitRequest) (*ControllerWaitResponse, error) {
+	var resp ControllerWaitResponse
+	if err := c.client.Call(ctx, "containerd.services.sandbox.v1.Controller", "Wait", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpccontrollerClient) Status(ctx context.Context, req *ControllerStatusRequest) (*ControllerStatusResponse, error) {
+	var resp ControllerStatusResponse
+	if err := c.client.Call(ctx, "containerd.services.sandbox.v1.Controller", "Status", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpccontrollerClient) Shutdown(ctx context.Context, req *ControllerShutdownRequest) (*ControllerShutdownResponse, error) {
+	var resp ControllerShutdownResponse
+	if err := c.client.Call(ctx, "containerd.services.sandbox.v1.Controller", "Shutdown", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpccontrollerClient) Metrics(ctx context.Context, req *ControllerMetricsRequest) (*ControllerMetricsResponse, error) {
+	var resp ControllerMetricsResponse
+	if err := c.client.Call(ctx, "containerd.services.sandbox.v1.Controller", "Metrics", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}

api/services/snapshots/v1/snapshots_ttrpc.pb.go

@@ -0,0 +1,242 @@
+// Code generated by protoc-gen-go-ttrpc. DO NOT EDIT.
+// source: github.com/containerd/containerd/api/services/snapshots/v1/snapshots.proto
+package snapshots
+
+import (
+	context "context"
+	ttrpc "github.com/containerd/ttrpc"
+	emptypb "google.golang.org/protobuf/types/known/emptypb"
+)
+
+type TTRPCSnapshotsService interface {
+	Prepare(context.Context, *PrepareSnapshotRequest) (*PrepareSnapshotResponse, error)
+	View(context.Context, *ViewSnapshotRequest) (*ViewSnapshotResponse, error)
+	Mounts(context.Context, *MountsRequest) (*MountsResponse, error)
+	Commit(context.Context, *CommitSnapshotRequest) (*emptypb.Empty, error)
+	Remove(context.Context, *RemoveSnapshotRequest) (*emptypb.Empty, error)
+	Stat(context.Context, *StatSnapshotRequest) (*StatSnapshotResponse, error)
+	Update(context.Context, *UpdateSnapshotRequest) (*UpdateSnapshotResponse, error)
+	List(context.Context, *ListSnapshotsRequest, TTRPCSnapshots_ListServer) error
+	Usage(context.Context, *UsageRequest) (*UsageResponse, error)
+	Cleanup(context.Context, *CleanupRequest) (*emptypb.Empty, error)
+}
+
+type TTRPCSnapshots_ListServer interface {
+	Send(*ListSnapshotsResponse) error
+	ttrpc.StreamServer
+}
+
+type ttrpcsnapshotsListServer struct {
+	ttrpc.StreamServer
+}
+
+func (x *ttrpcsnapshotsListServer) Send(m *ListSnapshotsResponse) error {
+	return x.StreamServer.SendMsg(m)
+}
+
+func RegisterTTRPCSnapshotsService(srv *ttrpc.Server, svc TTRPCSnapshotsService) {
+	srv.RegisterService("containerd.services.snapshots.v1.Snapshots", &ttrpc.ServiceDesc{
+		Methods: map[string]ttrpc.Method{
+			"Prepare": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req PrepareSnapshotRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Prepare(ctx, &req)
+			},
+			"View": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req ViewSnapshotRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.View(ctx, &req)
+			},
+			"Mounts": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req MountsRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Mounts(ctx, &req)
+			},
+			"Commit": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req CommitSnapshotRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Commit(ctx, &req)
+			},
+			"Remove": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req RemoveSnapshotRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Remove(ctx, &req)
+			},
+			"Stat": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req StatSnapshotRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Stat(ctx, &req)
+			},
+			"Update": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req UpdateSnapshotRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Update(ctx, &req)
+			},
+			"Usage": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req UsageRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Usage(ctx, &req)
+			},
+			"Cleanup": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req CleanupRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Cleanup(ctx, &req)
+			},
+		},
+		Streams: map[string]ttrpc.Stream{
+			"List": {
+				Handler: func(ctx context.Context, stream ttrpc.StreamServer) (interface{}, error) {
+					m := new(ListSnapshotsRequest)
+					if err := stream.RecvMsg(m); err != nil {
+						return nil, err
+					}
+					return nil, svc.List(ctx, m, &ttrpcsnapshotsListServer{stream})
+				},
+				StreamingClient: false,
+				StreamingServer: true,
+			},
+		},
+	})
+}
+
+type TTRPCSnapshotsClient interface {
+	Prepare(context.Context, *PrepareSnapshotRequest) (*PrepareSnapshotResponse, error)
+	View(context.Context, *ViewSnapshotRequest) (*ViewSnapshotResponse, error)
+	Mounts(context.Context, *MountsRequest) (*MountsResponse, error)
+	Commit(context.Context, *CommitSnapshotRequest) (*emptypb.Empty, error)
+	Remove(context.Context, *RemoveSnapshotRequest) (*emptypb.Empty, error)
+	Stat(context.Context, *StatSnapshotRequest) (*StatSnapshotResponse, error)
+	Update(context.Context, *UpdateSnapshotRequest) (*UpdateSnapshotResponse, error)
+	List(context.Context, *ListSnapshotsRequest) (TTRPCSnapshots_ListClient, error)
+	Usage(context.Context, *UsageRequest) (*UsageResponse, error)
+	Cleanup(context.Context, *CleanupRequest) (*emptypb.Empty, error)
+}
+
+type ttrpcsnapshotsClient struct {
+	client *ttrpc.Client
+}
+
+func NewTTRPCSnapshotsClient(client *ttrpc.Client) TTRPCSnapshotsClient {
+	return &ttrpcsnapshotsClient{
+		client: client,
+	}
+}
+
+func (c *ttrpcsnapshotsClient) Prepare(ctx context.Context, req *PrepareSnapshotRequest) (*PrepareSnapshotResponse, error) {
+	var resp PrepareSnapshotResponse
+	if err := c.client.Call(ctx, "containerd.services.snapshots.v1.Snapshots", "Prepare", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpcsnapshotsClient) View(ctx context.Context, req *ViewSnapshotRequest) (*ViewSnapshotResponse, error) {
+	var resp ViewSnapshotResponse
+	if err := c.client.Call(ctx, "containerd.services.snapshots.v1.Snapshots", "View", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpcsnapshotsClient) Mounts(ctx context.Context, req *MountsRequest) (*MountsResponse, error) {
+	var resp MountsResponse
+	if err := c.client.Call(ctx, "containerd.services.snapshots.v1.Snapshots", "Mounts", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpcsnapshotsClient) Commit(ctx context.Context, req *CommitSnapshotRequest) (*emptypb.Empty, error) {
+	var resp emptypb.Empty
+	if err := c.client.Call(ctx, "containerd.services.snapshots.v1.Snapshots", "Commit", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpcsnapshotsClient) Remove(ctx context.Context, req *RemoveSnapshotRequest) (*emptypb.Empty, error) {
+	var resp emptypb.Empty
+	if err := c.client.Call(ctx, "containerd.services.snapshots.v1.Snapshots", "Remove", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpcsnapshotsClient) Stat(ctx context.Context, req *StatSnapshotRequest) (*StatSnapshotResponse, error) {
+	var resp StatSnapshotResponse
+	if err := c.client.Call(ctx, "containerd.services.snapshots.v1.Snapshots", "Stat", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpcsnapshotsClient) Update(ctx context.Context, req *UpdateSnapshotRequest) (*UpdateSnapshotResponse, error) {
+	var resp UpdateSnapshotResponse
+	if err := c.client.Call(ctx, "containerd.services.snapshots.v1.Snapshots", "Update", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpcsnapshotsClient) List(ctx context.Context, req *ListSnapshotsRequest) (TTRPCSnapshots_ListClient, error) {
+	stream, err := c.client.NewStream(ctx, &ttrpc.StreamDesc{
+		StreamingClient: false,
+		StreamingServer: true,
+	}, "containerd.services.snapshots.v1.Snapshots", "List", req)
+	if err != nil {
+		return nil, err
+	}
+	x := &ttrpcsnapshotsListClient{stream}
+	return x, nil
+}
+
+type TTRPCSnapshots_ListClient interface {
+	Recv() (*ListSnapshotsResponse, error)
+	ttrpc.ClientStream
+}
+
+type ttrpcsnapshotsListClient struct {
+	ttrpc.ClientStream
+}
+
+func (x *ttrpcsnapshotsListClient) Recv() (*ListSnapshotsResponse, error) {
+	m := new(ListSnapshotsResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *ttrpcsnapshotsClient) Usage(ctx context.Context, req *UsageRequest) (*UsageResponse, error) {
+	var resp UsageResponse
+	if err := c.client.Call(ctx, "containerd.services.snapshots.v1.Snapshots", "Usage", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpcsnapshotsClient) Cleanup(ctx context.Context, req *CleanupRequest) (*emptypb.Empty, error) {
+	var resp emptypb.Empty
+	if err := c.client.Call(ctx, "containerd.services.snapshots.v1.Snapshots", "Cleanup", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}

api/services/streaming/v1/streaming_ttrpc.pb.go

@@ -0,0 +1,97 @@
+// Code generated by protoc-gen-go-ttrpc. DO NOT EDIT.
+// source: github.com/containerd/containerd/api/services/streaming/v1/streaming.proto
+package streaming
+
+import (
+	context "context"
+	ttrpc "github.com/containerd/ttrpc"
+	anypb "google.golang.org/protobuf/types/known/anypb"
+)
+
+type TTRPCStreamingService interface {
+	Stream(context.Context, TTRPCStreaming_StreamServer) error
+}
+
+type TTRPCStreaming_StreamServer interface {
+	Send(*anypb.Any) error
+	Recv() (*anypb.Any, error)
+	ttrpc.StreamServer
+}
+
+type ttrpcstreamingStreamServer struct {
+	ttrpc.StreamServer
+}
+
+func (x *ttrpcstreamingStreamServer) Send(m *anypb.Any) error {
+	return x.StreamServer.SendMsg(m)
+}
+
+func (x *ttrpcstreamingStreamServer) Recv() (*anypb.Any, error) {
+	m := new(anypb.Any)
+	if err := x.StreamServer.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func RegisterTTRPCStreamingService(srv *ttrpc.Server, svc TTRPCStreamingService) {
+	srv.RegisterService("containerd.services.streaming.v1.Streaming", &ttrpc.ServiceDesc{
+		Streams: map[string]ttrpc.Stream{
+			"Stream": {
+				Handler: func(ctx context.Context, stream ttrpc.StreamServer) (interface{}, error) {
+					return nil, svc.Stream(ctx, &ttrpcstreamingStreamServer{stream})
+				},
+				StreamingClient: true,
+				StreamingServer: true,
+			},
+		},
+	})
+}
+
+type TTRPCStreamingClient interface {
+	Stream(context.Context) (TTRPCStreaming_StreamClient, error)
+}
+
+type ttrpcstreamingClient struct {
+	client *ttrpc.Client
+}
+
+func NewTTRPCStreamingClient(client *ttrpc.Client) TTRPCStreamingClient {
+	return &ttrpcstreamingClient{
+		client: client,
+	}
+}
+
+func (c *ttrpcstreamingClient) Stream(ctx context.Context) (TTRPCStreaming_StreamClient, error) {
+	stream, err := c.client.NewStream(ctx, &ttrpc.StreamDesc{
+		StreamingClient: true,
+		StreamingServer: true,
+	}, "containerd.services.streaming.v1.Streaming", "Stream", nil)
+	if err != nil {
+		return nil, err
+	}
+	x := &ttrpcstreamingStreamClient{stream}
+	return x, nil
+}
+
+type TTRPCStreaming_StreamClient interface {
+	Send(*anypb.Any) error
+	Recv() (*anypb.Any, error)
+	ttrpc.ClientStream
+}
+
+type ttrpcstreamingStreamClient struct {
+	ttrpc.ClientStream
+}
+
+func (x *ttrpcstreamingStreamClient) Send(m *anypb.Any) error {
+	return x.ClientStream.SendMsg(m)
+}
+
+func (x *ttrpcstreamingStreamClient) Recv() (*anypb.Any, error) {
+	m := new(anypb.Any)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}

api/services/tasks/v1/tasks_ttrpc.pb.go

@@ -0,0 +1,301 @@
+// Code generated by protoc-gen-go-ttrpc. DO NOT EDIT.
+// source: github.com/containerd/containerd/api/services/tasks/v1/tasks.proto
+package tasks
+
+import (
+	context "context"
+	ttrpc "github.com/containerd/ttrpc"
+	emptypb "google.golang.org/protobuf/types/known/emptypb"
+)
+
+type TTRPCTasksService interface {
+	Create(context.Context, *CreateTaskRequest) (*CreateTaskResponse, error)
+	Start(context.Context, *StartRequest) (*StartResponse, error)
+	Delete(context.Context, *DeleteTaskRequest) (*DeleteResponse, error)
+	DeleteProcess(context.Context, *DeleteProcessRequest) (*DeleteResponse, error)
+	Get(context.Context, *GetRequest) (*GetResponse, error)
+	List(context.Context, *ListTasksRequest) (*ListTasksResponse, error)
+	Kill(context.Context, *KillRequest) (*emptypb.Empty, error)
+	Exec(context.Context, *ExecProcessRequest) (*emptypb.Empty, error)
+	ResizePty(context.Context, *ResizePtyRequest) (*emptypb.Empty, error)
+	CloseIO(context.Context, *CloseIORequest) (*emptypb.Empty, error)
+	Pause(context.Context, *PauseTaskRequest) (*emptypb.Empty, error)
+	Resume(context.Context, *ResumeTaskRequest) (*emptypb.Empty, error)
+	ListPids(context.Context, *ListPidsRequest) (*ListPidsResponse, error)
+	Checkpoint(context.Context, *CheckpointTaskRequest) (*CheckpointTaskResponse, error)
+	Update(context.Context, *UpdateTaskRequest) (*emptypb.Empty, error)
+	Metrics(context.Context, *MetricsRequest) (*MetricsResponse, error)
+	Wait(context.Context, *WaitRequest) (*WaitResponse, error)
+}
+
+func RegisterTTRPCTasksService(srv *ttrpc.Server, svc TTRPCTasksService) {
+	srv.RegisterService("containerd.services.tasks.v1.Tasks", &ttrpc.ServiceDesc{
+		Methods: map[string]ttrpc.Method{
+			"Create": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req CreateTaskRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Create(ctx, &req)
+			},
+			"Start": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req StartRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Start(ctx, &req)
+			},
+			"Delete": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req DeleteTaskRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Delete(ctx, &req)
+			},
+			"DeleteProcess": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req DeleteProcessRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.DeleteProcess(ctx, &req)
+			},
+			"Get": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req GetRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Get(ctx, &req)
+			},
+			"List": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req ListTasksRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.List(ctx, &req)
+			},
+			"Kill": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req KillRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Kill(ctx, &req)
+			},
+			"Exec": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req ExecProcessRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Exec(ctx, &req)
+			},
+			"ResizePty": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req ResizePtyRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.ResizePty(ctx, &req)
+			},
+			"CloseIO": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req CloseIORequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.CloseIO(ctx, &req)
+			},
+			"Pause": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req PauseTaskRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Pause(ctx, &req)
+			},
+			"Resume": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req ResumeTaskRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Resume(ctx, &req)
+			},
+			"ListPids": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req ListPidsRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.ListPids(ctx, &req)
+			},
+			"Checkpoint": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req CheckpointTaskRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Checkpoint(ctx, &req)
+			},
+			"Update": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req UpdateTaskRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Update(ctx, &req)
+			},
+			"Metrics": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req MetricsRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Metrics(ctx, &req)
+			},
+			"Wait": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req WaitRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Wait(ctx, &req)
+			},
+		},
+	})
+}
+
+type ttrpctasksClient struct {
+	client *ttrpc.Client
+}
+
+func NewTTRPCTasksClient(client *ttrpc.Client) TTRPCTasksService {
+	return &ttrpctasksClient{
+		client: client,
+	}
+}
+
+func (c *ttrpctasksClient) Create(ctx context.Context, req *CreateTaskRequest) (*CreateTaskResponse, error) {
+	var resp CreateTaskResponse
+	if err := c.client.Call(ctx, "containerd.services.tasks.v1.Tasks", "Create", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpctasksClient) Start(ctx context.Context, req *StartRequest) (*StartResponse, error) {
+	var resp StartResponse
+	if err := c.client.Call(ctx, "containerd.services.tasks.v1.Tasks", "Start", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpctasksClient) Delete(ctx context.Context, req *DeleteTaskRequest) (*DeleteResponse, error) {
+	var resp DeleteResponse
+	if err := c.client.Call(ctx, "containerd.services.tasks.v1.Tasks", "Delete", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpctasksClient) DeleteProcess(ctx context.Context, req *DeleteProcessRequest) (*DeleteResponse, error) {
+	var resp DeleteResponse
+	if err := c.client.Call(ctx, "containerd.services.tasks.v1.Tasks", "DeleteProcess", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpctasksClient) Get(ctx context.Context, req *GetRequest) (*GetResponse, error) {
+	var resp GetResponse
+	if err := c.client.Call(ctx, "containerd.services.tasks.v1.Tasks", "Get", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpctasksClient) List(ctx context.Context, req *ListTasksRequest) (*ListTasksResponse, error) {
+	var resp ListTasksResponse
+	if err := c.client.Call(ctx, "containerd.services.tasks.v1.Tasks", "List", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpctasksClient) Kill(ctx context.Context, req *KillRequest) (*emptypb.Empty, error) {
+	var resp emptypb.Empty
+	if err := c.client.Call(ctx, "containerd.services.tasks.v1.Tasks", "Kill", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpctasksClient) Exec(ctx context.Context, req *ExecProcessRequest) (*emptypb.Empty, error) {
+	var resp emptypb.Empty
+	if err := c.client.Call(ctx, "containerd.services.tasks.v1.Tasks", "Exec", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpctasksClient) ResizePty(ctx context.Context, req *ResizePtyRequest) (*emptypb.Empty, error) {
+	var resp emptypb.Empty
+	if err := c.client.Call(ctx, "containerd.services.tasks.v1.Tasks", "ResizePty", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpctasksClient) CloseIO(ctx context.Context, req *CloseIORequest) (*emptypb.Empty, error) {
+	var resp emptypb.Empty
+	if err := c.client.Call(ctx, "containerd.services.tasks.v1.Tasks", "CloseIO", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpctasksClient) Pause(ctx context.Context, req *PauseTaskRequest) (*emptypb.Empty, error) {
+	var resp emptypb.Empty
+	if err := c.client.Call(ctx, "containerd.services.tasks.v1.Tasks", "Pause", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpctasksClient) Resume(ctx context.Context, req *ResumeTaskRequest) (*emptypb.Empty, error) {
+	var resp emptypb.Empty
+	if err := c.client.Call(ctx, "containerd.services.tasks.v1.Tasks", "Resume", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpctasksClient) ListPids(ctx context.Context, req *ListPidsRequest) (*ListPidsResponse, error) {
+	var resp ListPidsResponse
+	if err := c.client.Call(ctx, "containerd.services.tasks.v1.Tasks", "ListPids", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpctasksClient) Checkpoint(ctx context.Context, req *CheckpointTaskRequest) (*CheckpointTaskResponse, error) {
+	var resp CheckpointTaskResponse
+	if err := c.client.Call(ctx, "containerd.services.tasks.v1.Tasks", "Checkpoint", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpctasksClient) Update(ctx context.Context, req *UpdateTaskRequest) (*emptypb.Empty, error) {
+	var resp emptypb.Empty
+	if err := c.client.Call(ctx, "containerd.services.tasks.v1.Tasks", "Update", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpctasksClient) Metrics(ctx context.Context, req *MetricsRequest) (*MetricsResponse, error) {
+	var resp MetricsResponse
+	if err := c.client.Call(ctx, "containerd.services.tasks.v1.Tasks", "Metrics", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *ttrpctasksClient) Wait(ctx context.Context, req *WaitRequest) (*WaitResponse, error) {
+	var resp WaitResponse
+	if err := c.client.Call(ctx, "containerd.services.tasks.v1.Tasks", "Wait", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}

api/services/transfer/v1/transfer_ttrpc.pb.go

@@ -0,0 +1,45 @@
+// Code generated by protoc-gen-go-ttrpc. DO NOT EDIT.
+// source: github.com/containerd/containerd/api/services/transfer/v1/transfer.proto
+package transfer
+
+import (
+	context "context"
+	ttrpc "github.com/containerd/ttrpc"
+	emptypb "google.golang.org/protobuf/types/known/emptypb"
+)
+
+type TTRPCTransferService interface {
+	Transfer(context.Context, *TransferRequest) (*emptypb.Empty, error)
+}
+
+func RegisterTTRPCTransferService(srv *ttrpc.Server, svc TTRPCTransferService) {
+	srv.RegisterService("containerd.services.transfer.v1.Transfer", &ttrpc.ServiceDesc{
+		Methods: map[string]ttrpc.Method{
+			"Transfer": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req TransferRequest
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Transfer(ctx, &req)
+			},
+		},
+	})
+}
+
+type ttrpctransferClient struct {
+	client *ttrpc.Client
+}
+
+func NewTTRPCTransferClient(client *ttrpc.Client) TTRPCTransferService {
+	return &ttrpctransferClient{
+		client: client,
+	}
+}
+
+func (c *ttrpctransferClient) Transfer(ctx context.Context, req *TransferRequest) (*emptypb.Empty, error) {
+	var resp emptypb.Empty
+	if err := c.client.Call(ctx, "containerd.services.transfer.v1.Transfer", "Transfer", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}

api/services/version/v1/version_ttrpc.pb.go

@@ -0,0 +1,45 @@
+// Code generated by protoc-gen-go-ttrpc. DO NOT EDIT.
+// source: github.com/containerd/containerd/api/services/version/v1/version.proto
+package version
+
+import (
+	context "context"
+	ttrpc "github.com/containerd/ttrpc"
+	emptypb "google.golang.org/protobuf/types/known/emptypb"
+)
+
+type TTRPCVersionService interface {
+	Version(context.Context, *emptypb.Empty) (*VersionResponse, error)
+}
+
+func RegisterTTRPCVersionService(srv *ttrpc.Server, svc TTRPCVersionService) {
+	srv.RegisterService("containerd.services.version.v1.Version", &ttrpc.ServiceDesc{
+		Methods: map[string]ttrpc.Method{
+			"Version": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+				var req emptypb.Empty
+				if err := unmarshal(&req); err != nil {
+					return nil, err
+				}
+				return svc.Version(ctx, &req)
+			},
+		},
+	})
+}
+
+type ttrpcversionClient struct {
+	client *ttrpc.Client
+}
+
+func NewTTRPCVersionClient(client *ttrpc.Client) TTRPCVersionService {
+	return &ttrpcversionClient{
+		client: client,
+	}
+}
+
+func (c *ttrpcversionClient) Version(ctx context.Context, req *emptypb.Empty) (*VersionResponse, error) {
+	var resp VersionResponse
+	if err := c.client.Call(ctx, "containerd.services.version.v1.Version", "Version", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}

script/setup/install-dev-tools

@@ -26,4 +26,4 @@ go install github.com/cpuguy83/go-md2man/v2@v2.0.2
 go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.54.2
 go install google.golang.org/protobuf/cmd/protoc-gen-go@v1.28
 go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@v1.2
-go install github.com/containerd/ttrpc/cmd/protoc-gen-go-ttrpc@5cc9169d1fc1a8292866224ae09dc47827801874
+go install github.com/containerd/ttrpc/cmd/protoc-gen-go-ttrpc@faba5896a9c4d7b65495cb9b2c02531feb1434d6