From da799ae314b480fd72c61631ae173257e9f8ea02 Mon Sep 17 00:00:00 2001 From: Derek McGowan Date: Mon, 31 Oct 2022 15:02:40 -0700 Subject: [PATCH] Generate proto services with go-ttrpc Signed-off-by: Derek McGowan --- api/Protobuild.toml | 14 +- .../containers/v1/containers_ttrpc.pb.go | 174 ++++++++++ api/services/content/v1/content_ttrpc.pb.go | 311 ++++++++++++++++++ api/services/diff/v1/diff_ttrpc.pb.go | 60 ++++ api/services/events/v1/events_ttrpc.pb.go | 123 +++++++ api/services/images/v1/images_ttrpc.pb.go | 109 ++++++ .../v1/introspection_ttrpc.pb.go | 61 ++++ api/services/leases/v1/leases_ttrpc.pb.go | 125 +++++++ .../namespaces/v1/namespace_ttrpc.pb.go | 109 ++++++ api/services/sandbox/v1/sandbox_ttrpc.pb.go | 224 +++++++++++++ .../snapshots/v1/snapshots_ttrpc.pb.go | 242 ++++++++++++++ .../streaming/v1/streaming_ttrpc.pb.go | 97 ++++++ api/services/tasks/v1/tasks_ttrpc.pb.go | 301 +++++++++++++++++ api/services/transfer/v1/transfer_ttrpc.pb.go | 45 +++ api/services/version/v1/version_ttrpc.pb.go | 45 +++ script/setup/install-dev-tools | 6 +- 16 files changed, 2042 insertions(+), 4 deletions(-) create mode 100644 api/services/containers/v1/containers_ttrpc.pb.go create mode 100644 api/services/content/v1/content_ttrpc.pb.go create mode 100644 api/services/diff/v1/diff_ttrpc.pb.go create mode 100644 api/services/events/v1/events_ttrpc.pb.go create mode 100644 api/services/images/v1/images_ttrpc.pb.go create mode 100644 api/services/introspection/v1/introspection_ttrpc.pb.go create mode 100644 api/services/leases/v1/leases_ttrpc.pb.go create mode 100644 api/services/namespaces/v1/namespace_ttrpc.pb.go create mode 100644 api/services/sandbox/v1/sandbox_ttrpc.pb.go create mode 100644 api/services/snapshots/v1/snapshots_ttrpc.pb.go create mode 100644 api/services/streaming/v1/streaming_ttrpc.pb.go create mode 100644 api/services/tasks/v1/tasks_ttrpc.pb.go create mode 100644 api/services/transfer/v1/transfer_ttrpc.pb.go create mode 100644 api/services/version/v1/version_ttrpc.pb.go diff --git a/api/Protobuild.toml b/api/Protobuild.toml index 518f5230c3498..4c39e4bc9d75e 100644 --- a/api/Protobuild.toml +++ b/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", "go-fieldpath"] +[overrides.parameters.go-ttrpc] +prefix = "" + [[overrides]] # enable ttrpc and disable fieldpath and grpc for the shim prefixes = [ @@ -35,6 +44,9 @@ prefixes = [ ] generators = ["go", "go-ttrpc"] +[overrides.parameters.go-ttrpc] +prefix = "" + # Aggregrate the API descriptors to lock down API changes. [[descriptors]] prefix = "github.com/containerd/containerd/api" diff --git a/api/services/containers/v1/containers_ttrpc.pb.go b/api/services/containers/v1/containers_ttrpc.pb.go new file mode 100644 index 0000000000000..8090011df33af --- /dev/null +++ b/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 +} diff --git a/api/services/content/v1/content_ttrpc.pb.go b/api/services/content/v1/content_ttrpc.pb.go new file mode 100644 index 0000000000000..efa241a2b2563 --- /dev/null +++ b/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 +} diff --git a/api/services/diff/v1/diff_ttrpc.pb.go b/api/services/diff/v1/diff_ttrpc.pb.go new file mode 100644 index 0000000000000..0aa063fb3d6c0 --- /dev/null +++ b/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 +} diff --git a/api/services/events/v1/events_ttrpc.pb.go b/api/services/events/v1/events_ttrpc.pb.go new file mode 100644 index 0000000000000..559d6d2c46a4f --- /dev/null +++ b/api/services/events/v1/events_ttrpc.pb.go @@ -0,0 +1,123 @@ +// 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" + 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(*Envelope) error + ttrpc.StreamServer +} + +type ttrpceventsSubscribeServer struct { + ttrpc.StreamServer +} + +func (x *ttrpceventsSubscribeServer) Send(m *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() (*Envelope, error) + ttrpc.ClientStream +} + +type ttrpceventsSubscribeClient struct { + ttrpc.ClientStream +} + +func (x *ttrpceventsSubscribeClient) Recv() (*Envelope, error) { + m := new(Envelope) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} diff --git a/api/services/images/v1/images_ttrpc.pb.go b/api/services/images/v1/images_ttrpc.pb.go new file mode 100644 index 0000000000000..442e1ac5c1a74 --- /dev/null +++ b/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 +} diff --git a/api/services/introspection/v1/introspection_ttrpc.pb.go b/api/services/introspection/v1/introspection_ttrpc.pb.go new file mode 100644 index 0000000000000..03c1237a9fe2c --- /dev/null +++ b/api/services/introspection/v1/introspection_ttrpc.pb.go @@ -0,0 +1,61 @@ +// 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) +} + +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) + }, + }, + }) +} + +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 +} diff --git a/api/services/leases/v1/leases_ttrpc.pb.go b/api/services/leases/v1/leases_ttrpc.pb.go new file mode 100644 index 0000000000000..af63dc0907bce --- /dev/null +++ b/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 +} diff --git a/api/services/namespaces/v1/namespace_ttrpc.pb.go b/api/services/namespaces/v1/namespace_ttrpc.pb.go new file mode 100644 index 0000000000000..09f94c1d1f152 --- /dev/null +++ b/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 +} diff --git a/api/services/sandbox/v1/sandbox_ttrpc.pb.go b/api/services/sandbox/v1/sandbox_ttrpc.pb.go new file mode 100644 index 0000000000000..3dc07bfaa6c83 --- /dev/null +++ b/api/services/sandbox/v1/sandbox_ttrpc.pb.go @@ -0,0 +1,224 @@ +// 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) + Stop(context.Context, *ControllerStopRequest) (*ControllerStopResponse, error) + Wait(context.Context, *ControllerWaitRequest) (*ControllerWaitResponse, error) + Status(context.Context, *ControllerStatusRequest) (*ControllerStatusResponse, error) + Shutdown(context.Context, *ControllerShutdownRequest) (*ControllerShutdownResponse, 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) + }, + "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) + }, + }, + }) +} + +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) 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 +} diff --git a/api/services/snapshots/v1/snapshots_ttrpc.pb.go b/api/services/snapshots/v1/snapshots_ttrpc.pb.go new file mode 100644 index 0000000000000..8ab278cb4e035 --- /dev/null +++ b/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 +} diff --git a/api/services/streaming/v1/streaming_ttrpc.pb.go b/api/services/streaming/v1/streaming_ttrpc.pb.go new file mode 100644 index 0000000000000..9e30233d43119 --- /dev/null +++ b/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 +} diff --git a/api/services/tasks/v1/tasks_ttrpc.pb.go b/api/services/tasks/v1/tasks_ttrpc.pb.go new file mode 100644 index 0000000000000..859eec58e0b1d --- /dev/null +++ b/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 +} diff --git a/api/services/transfer/v1/transfer_ttrpc.pb.go b/api/services/transfer/v1/transfer_ttrpc.pb.go new file mode 100644 index 0000000000000..848eb1933fa0c --- /dev/null +++ b/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 +} diff --git a/api/services/version/v1/version_ttrpc.pb.go b/api/services/version/v1/version_ttrpc.pb.go new file mode 100644 index 0000000000000..c284f14e72d8c --- /dev/null +++ b/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 +} diff --git a/script/setup/install-dev-tools b/script/setup/install-dev-tools index 46136d4a3c28a..a875c15954007 100755 --- a/script/setup/install-dev-tools +++ b/script/setup/install-dev-tools @@ -20,10 +20,10 @@ set -eu -o pipefail # install `protobuild` and other commands -go install github.com/containerd/protobuild@v0.2.0 -go install github.com/containerd/protobuild/cmd/go-fix-acronym@v0.2.0 +go install github.com/containerd/protobuild@14832ccc41429f5c4f81028e5af08aa233a219cf +go install github.com/containerd/protobuild/cmd/go-fix-acronym@14832ccc41429f5c4f81028e5af08aa233a219cf go install github.com/cpuguy83/go-md2man/v2@v2.0.2 go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.50.1 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@944ef4a40df3446714a823207972b7d9858ffac5 +go install github.com/containerd/ttrpc/cmd/protoc-gen-go-ttrpc@89444d66c45d7d68f47b15ad80ec5f106494a5b3