github/containerd
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

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

Browse Source 
Generate proto services with go-ttrpc
This commit is contained in:
Maksym Pavlenko 2024-02-22 20:38:21 +00:00 committed by GitHub
commit 65588b5238
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
16 changed files with 2089 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
api/Protobuild.toml
View File

@ -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"

174
api/services/containers/v1/containers_ttrpc.pb.go Normal file
View File

@ -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
}

311
api/services/content/v1/content_ttrpc.pb.go Normal file
View File

@ -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
}

60
api/services/diff/v1/diff_ttrpc.pb.go Normal file
View File

@ -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
}

124
api/services/events/v1/events_ttrpc.pb.go Normal file
View File

@ -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
}

109
api/services/images/v1/images_ttrpc.pb.go Normal file
View File

@ -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
}

77
api/services/introspection/v1/introspection_ttrpc.pb.go Normal file
View File

@ -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
}

125
api/services/leases/v1/leases_ttrpc.pb.go Normal file
View File

@ -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
}

109
api/services/namespaces/v1/namespace_ttrpc.pb.go Normal file
View File

@ -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
}

256
api/services/sandbox/v1/sandbox_ttrpc.pb.go Normal file
View File

@ -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
}

242
api/services/snapshots/v1/snapshots_ttrpc.pb.go Normal file
View File

@ -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
}

97
api/services/streaming/v1/streaming_ttrpc.pb.go Normal file
View File

@ -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
}

301
api/services/tasks/v1/tasks_ttrpc.pb.go Normal file
View File

@ -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
}

45
api/services/transfer/v1/transfer_ttrpc.pb.go Normal file
View File

@ -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
}

45
api/services/version/v1/version_ttrpc.pb.go Normal file
View File

@ -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
}

2
script/setup/install-dev-tools
View File

@ -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