2123855eeb
This is needed so we can build the runc shim without grpc as a transative dependency. With this change the runc shim binary went from 14MB to 11MB. The RSS from an idle shim went from about 17MB to 14MB (back around where it was in in 1.7). Signed-off-by: Brian Goff <cpuguy83@gmail.com>
572 lines
19 KiB
Go
572 lines
19 KiB
Go
//go:build !no_grpc
|
|
|
|
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
|
|
// versions:
|
|
// - protoc-gen-go-grpc v1.2.0
|
|
// - protoc v3.20.1
|
|
// source: github.com/containerd/containerd/api/services/content/v1/content.proto
|
|
|
|
package content
|
|
|
|
import (
|
|
context "context"
|
|
grpc "google.golang.org/grpc"
|
|
codes "google.golang.org/grpc/codes"
|
|
status "google.golang.org/grpc/status"
|
|
emptypb "google.golang.org/protobuf/types/known/emptypb"
|
|
)
|
|
|
|
// This is a compile-time assertion to ensure that this generated file
|
|
// is compatible with the grpc package it is being compiled against.
|
|
// Requires gRPC-Go v1.32.0 or later.
|
|
const _ = grpc.SupportPackageIsVersion7
|
|
|
|
// ContentClient is the client API for Content service.
|
|
//
|
|
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
|
|
type ContentClient interface {
|
|
// Info returns information about a committed object.
|
|
//
|
|
// This call can be used for getting the size of content and checking for
|
|
// existence.
|
|
Info(ctx context.Context, in *InfoRequest, opts ...grpc.CallOption) (*InfoResponse, error)
|
|
// Update updates content metadata.
|
|
//
|
|
// This call can be used to manage the mutable content labels. The
|
|
// immutable metadata such as digest, size, and committed at cannot
|
|
// be updated.
|
|
Update(ctx context.Context, in *UpdateRequest, opts ...grpc.CallOption) (*UpdateResponse, error)
|
|
// List streams the entire set of content as Info objects and closes the
|
|
// stream.
|
|
//
|
|
// Typically, this will yield a large response, chunked into messages.
|
|
// Clients should make provisions to ensure they can handle the entire data
|
|
// set.
|
|
List(ctx context.Context, in *ListContentRequest, opts ...grpc.CallOption) (Content_ListClient, error)
|
|
// Delete will delete the referenced object.
|
|
Delete(ctx context.Context, in *DeleteContentRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
|
|
// Read allows one to read an object based on the offset into the content.
|
|
//
|
|
// The requested data may be returned in one or more messages.
|
|
Read(ctx context.Context, in *ReadContentRequest, opts ...grpc.CallOption) (Content_ReadClient, error)
|
|
// Status returns the status for a single reference.
|
|
Status(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (*StatusResponse, error)
|
|
// ListStatuses returns the status of ongoing object ingestions, started via
|
|
// Write.
|
|
//
|
|
// Only those matching the regular expression will be provided in the
|
|
// response. If the provided regular expression is empty, all ingestions
|
|
// will be provided.
|
|
ListStatuses(ctx context.Context, in *ListStatusesRequest, opts ...grpc.CallOption) (*ListStatusesResponse, error)
|
|
// Write begins or resumes writes to a resource identified by a unique ref.
|
|
// Only one active stream may exist at a time for each ref.
|
|
//
|
|
// Once a write stream has started, it may only write to a single ref, thus
|
|
// once a stream is started, the ref may be omitted on subsequent writes.
|
|
//
|
|
// For any write transaction represented by a ref, only a single write may
|
|
// be made to a given offset. If overlapping writes occur, it is an error.
|
|
// Writes should be sequential and implementations may throw an error if
|
|
// this is required.
|
|
//
|
|
// If expected_digest is set and already part of the content store, the
|
|
// write will fail.
|
|
//
|
|
// When completed, the commit flag should be set to true. If expected size
|
|
// or digest is set, the content will be validated against those values.
|
|
Write(ctx context.Context, opts ...grpc.CallOption) (Content_WriteClient, error)
|
|
// Abort cancels the ongoing write named in the request. Any resources
|
|
// associated with the write will be collected.
|
|
Abort(ctx context.Context, in *AbortRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
|
|
}
|
|
|
|
type contentClient struct {
|
|
cc grpc.ClientConnInterface
|
|
}
|
|
|
|
func NewContentClient(cc grpc.ClientConnInterface) ContentClient {
|
|
return &contentClient{cc}
|
|
}
|
|
|
|
func (c *contentClient) Info(ctx context.Context, in *InfoRequest, opts ...grpc.CallOption) (*InfoResponse, error) {
|
|
out := new(InfoResponse)
|
|
err := c.cc.Invoke(ctx, "/containerd.services.content.v1.Content/Info", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *contentClient) Update(ctx context.Context, in *UpdateRequest, opts ...grpc.CallOption) (*UpdateResponse, error) {
|
|
out := new(UpdateResponse)
|
|
err := c.cc.Invoke(ctx, "/containerd.services.content.v1.Content/Update", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *contentClient) List(ctx context.Context, in *ListContentRequest, opts ...grpc.CallOption) (Content_ListClient, error) {
|
|
stream, err := c.cc.NewStream(ctx, &Content_ServiceDesc.Streams[0], "/containerd.services.content.v1.Content/List", opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
x := &contentListClient{stream}
|
|
if err := x.ClientStream.SendMsg(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := x.ClientStream.CloseSend(); err != nil {
|
|
return nil, err
|
|
}
|
|
return x, nil
|
|
}
|
|
|
|
type Content_ListClient interface {
|
|
Recv() (*ListContentResponse, error)
|
|
grpc.ClientStream
|
|
}
|
|
|
|
type contentListClient struct {
|
|
grpc.ClientStream
|
|
}
|
|
|
|
func (x *contentListClient) Recv() (*ListContentResponse, error) {
|
|
m := new(ListContentResponse)
|
|
if err := x.ClientStream.RecvMsg(m); err != nil {
|
|
return nil, err
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
func (c *contentClient) Delete(ctx context.Context, in *DeleteContentRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
|
|
out := new(emptypb.Empty)
|
|
err := c.cc.Invoke(ctx, "/containerd.services.content.v1.Content/Delete", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *contentClient) Read(ctx context.Context, in *ReadContentRequest, opts ...grpc.CallOption) (Content_ReadClient, error) {
|
|
stream, err := c.cc.NewStream(ctx, &Content_ServiceDesc.Streams[1], "/containerd.services.content.v1.Content/Read", opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
x := &contentReadClient{stream}
|
|
if err := x.ClientStream.SendMsg(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := x.ClientStream.CloseSend(); err != nil {
|
|
return nil, err
|
|
}
|
|
return x, nil
|
|
}
|
|
|
|
type Content_ReadClient interface {
|
|
Recv() (*ReadContentResponse, error)
|
|
grpc.ClientStream
|
|
}
|
|
|
|
type contentReadClient struct {
|
|
grpc.ClientStream
|
|
}
|
|
|
|
func (x *contentReadClient) Recv() (*ReadContentResponse, error) {
|
|
m := new(ReadContentResponse)
|
|
if err := x.ClientStream.RecvMsg(m); err != nil {
|
|
return nil, err
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
func (c *contentClient) Status(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (*StatusResponse, error) {
|
|
out := new(StatusResponse)
|
|
err := c.cc.Invoke(ctx, "/containerd.services.content.v1.Content/Status", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *contentClient) ListStatuses(ctx context.Context, in *ListStatusesRequest, opts ...grpc.CallOption) (*ListStatusesResponse, error) {
|
|
out := new(ListStatusesResponse)
|
|
err := c.cc.Invoke(ctx, "/containerd.services.content.v1.Content/ListStatuses", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *contentClient) Write(ctx context.Context, opts ...grpc.CallOption) (Content_WriteClient, error) {
|
|
stream, err := c.cc.NewStream(ctx, &Content_ServiceDesc.Streams[2], "/containerd.services.content.v1.Content/Write", opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
x := &contentWriteClient{stream}
|
|
return x, nil
|
|
}
|
|
|
|
type Content_WriteClient interface {
|
|
Send(*WriteContentRequest) error
|
|
Recv() (*WriteContentResponse, error)
|
|
grpc.ClientStream
|
|
}
|
|
|
|
type contentWriteClient struct {
|
|
grpc.ClientStream
|
|
}
|
|
|
|
func (x *contentWriteClient) Send(m *WriteContentRequest) error {
|
|
return x.ClientStream.SendMsg(m)
|
|
}
|
|
|
|
func (x *contentWriteClient) Recv() (*WriteContentResponse, error) {
|
|
m := new(WriteContentResponse)
|
|
if err := x.ClientStream.RecvMsg(m); err != nil {
|
|
return nil, err
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
func (c *contentClient) Abort(ctx context.Context, in *AbortRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
|
|
out := new(emptypb.Empty)
|
|
err := c.cc.Invoke(ctx, "/containerd.services.content.v1.Content/Abort", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// ContentServer is the server API for Content service.
|
|
// All implementations must embed UnimplementedContentServer
|
|
// for forward compatibility
|
|
type ContentServer interface {
|
|
// Info returns information about a committed object.
|
|
//
|
|
// This call can be used for getting the size of content and checking for
|
|
// existence.
|
|
Info(context.Context, *InfoRequest) (*InfoResponse, error)
|
|
// Update updates content metadata.
|
|
//
|
|
// This call can be used to manage the mutable content labels. The
|
|
// immutable metadata such as digest, size, and committed at cannot
|
|
// be updated.
|
|
Update(context.Context, *UpdateRequest) (*UpdateResponse, error)
|
|
// List streams the entire set of content as Info objects and closes the
|
|
// stream.
|
|
//
|
|
// Typically, this will yield a large response, chunked into messages.
|
|
// Clients should make provisions to ensure they can handle the entire data
|
|
// set.
|
|
List(*ListContentRequest, Content_ListServer) error
|
|
// Delete will delete the referenced object.
|
|
Delete(context.Context, *DeleteContentRequest) (*emptypb.Empty, error)
|
|
// Read allows one to read an object based on the offset into the content.
|
|
//
|
|
// The requested data may be returned in one or more messages.
|
|
Read(*ReadContentRequest, Content_ReadServer) error
|
|
// Status returns the status for a single reference.
|
|
Status(context.Context, *StatusRequest) (*StatusResponse, error)
|
|
// ListStatuses returns the status of ongoing object ingestions, started via
|
|
// Write.
|
|
//
|
|
// Only those matching the regular expression will be provided in the
|
|
// response. If the provided regular expression is empty, all ingestions
|
|
// will be provided.
|
|
ListStatuses(context.Context, *ListStatusesRequest) (*ListStatusesResponse, error)
|
|
// Write begins or resumes writes to a resource identified by a unique ref.
|
|
// Only one active stream may exist at a time for each ref.
|
|
//
|
|
// Once a write stream has started, it may only write to a single ref, thus
|
|
// once a stream is started, the ref may be omitted on subsequent writes.
|
|
//
|
|
// For any write transaction represented by a ref, only a single write may
|
|
// be made to a given offset. If overlapping writes occur, it is an error.
|
|
// Writes should be sequential and implementations may throw an error if
|
|
// this is required.
|
|
//
|
|
// If expected_digest is set and already part of the content store, the
|
|
// write will fail.
|
|
//
|
|
// When completed, the commit flag should be set to true. If expected size
|
|
// or digest is set, the content will be validated against those values.
|
|
Write(Content_WriteServer) error
|
|
// Abort cancels the ongoing write named in the request. Any resources
|
|
// associated with the write will be collected.
|
|
Abort(context.Context, *AbortRequest) (*emptypb.Empty, error)
|
|
mustEmbedUnimplementedContentServer()
|
|
}
|
|
|
|
// UnimplementedContentServer must be embedded to have forward compatible implementations.
|
|
type UnimplementedContentServer struct {
|
|
}
|
|
|
|
func (UnimplementedContentServer) Info(context.Context, *InfoRequest) (*InfoResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method Info not implemented")
|
|
}
|
|
func (UnimplementedContentServer) Update(context.Context, *UpdateRequest) (*UpdateResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method Update not implemented")
|
|
}
|
|
func (UnimplementedContentServer) List(*ListContentRequest, Content_ListServer) error {
|
|
return status.Errorf(codes.Unimplemented, "method List not implemented")
|
|
}
|
|
func (UnimplementedContentServer) Delete(context.Context, *DeleteContentRequest) (*emptypb.Empty, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
|
|
}
|
|
func (UnimplementedContentServer) Read(*ReadContentRequest, Content_ReadServer) error {
|
|
return status.Errorf(codes.Unimplemented, "method Read not implemented")
|
|
}
|
|
func (UnimplementedContentServer) Status(context.Context, *StatusRequest) (*StatusResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method Status not implemented")
|
|
}
|
|
func (UnimplementedContentServer) ListStatuses(context.Context, *ListStatusesRequest) (*ListStatusesResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method ListStatuses not implemented")
|
|
}
|
|
func (UnimplementedContentServer) Write(Content_WriteServer) error {
|
|
return status.Errorf(codes.Unimplemented, "method Write not implemented")
|
|
}
|
|
func (UnimplementedContentServer) Abort(context.Context, *AbortRequest) (*emptypb.Empty, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method Abort not implemented")
|
|
}
|
|
func (UnimplementedContentServer) mustEmbedUnimplementedContentServer() {}
|
|
|
|
// UnsafeContentServer may be embedded to opt out of forward compatibility for this service.
|
|
// Use of this interface is not recommended, as added methods to ContentServer will
|
|
// result in compilation errors.
|
|
type UnsafeContentServer interface {
|
|
mustEmbedUnimplementedContentServer()
|
|
}
|
|
|
|
func RegisterContentServer(s grpc.ServiceRegistrar, srv ContentServer) {
|
|
s.RegisterService(&Content_ServiceDesc, srv)
|
|
}
|
|
|
|
func _Content_Info_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(InfoRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ContentServer).Info(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/containerd.services.content.v1.Content/Info",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ContentServer).Info(ctx, req.(*InfoRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Content_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(UpdateRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ContentServer).Update(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/containerd.services.content.v1.Content/Update",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ContentServer).Update(ctx, req.(*UpdateRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Content_List_Handler(srv interface{}, stream grpc.ServerStream) error {
|
|
m := new(ListContentRequest)
|
|
if err := stream.RecvMsg(m); err != nil {
|
|
return err
|
|
}
|
|
return srv.(ContentServer).List(m, &contentListServer{stream})
|
|
}
|
|
|
|
type Content_ListServer interface {
|
|
Send(*ListContentResponse) error
|
|
grpc.ServerStream
|
|
}
|
|
|
|
type contentListServer struct {
|
|
grpc.ServerStream
|
|
}
|
|
|
|
func (x *contentListServer) Send(m *ListContentResponse) error {
|
|
return x.ServerStream.SendMsg(m)
|
|
}
|
|
|
|
func _Content_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(DeleteContentRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ContentServer).Delete(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/containerd.services.content.v1.Content/Delete",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ContentServer).Delete(ctx, req.(*DeleteContentRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Content_Read_Handler(srv interface{}, stream grpc.ServerStream) error {
|
|
m := new(ReadContentRequest)
|
|
if err := stream.RecvMsg(m); err != nil {
|
|
return err
|
|
}
|
|
return srv.(ContentServer).Read(m, &contentReadServer{stream})
|
|
}
|
|
|
|
type Content_ReadServer interface {
|
|
Send(*ReadContentResponse) error
|
|
grpc.ServerStream
|
|
}
|
|
|
|
type contentReadServer struct {
|
|
grpc.ServerStream
|
|
}
|
|
|
|
func (x *contentReadServer) Send(m *ReadContentResponse) error {
|
|
return x.ServerStream.SendMsg(m)
|
|
}
|
|
|
|
func _Content_Status_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(StatusRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ContentServer).Status(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/containerd.services.content.v1.Content/Status",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ContentServer).Status(ctx, req.(*StatusRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Content_ListStatuses_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(ListStatusesRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ContentServer).ListStatuses(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/containerd.services.content.v1.Content/ListStatuses",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ContentServer).ListStatuses(ctx, req.(*ListStatusesRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Content_Write_Handler(srv interface{}, stream grpc.ServerStream) error {
|
|
return srv.(ContentServer).Write(&contentWriteServer{stream})
|
|
}
|
|
|
|
type Content_WriteServer interface {
|
|
Send(*WriteContentResponse) error
|
|
Recv() (*WriteContentRequest, error)
|
|
grpc.ServerStream
|
|
}
|
|
|
|
type contentWriteServer struct {
|
|
grpc.ServerStream
|
|
}
|
|
|
|
func (x *contentWriteServer) Send(m *WriteContentResponse) error {
|
|
return x.ServerStream.SendMsg(m)
|
|
}
|
|
|
|
func (x *contentWriteServer) Recv() (*WriteContentRequest, error) {
|
|
m := new(WriteContentRequest)
|
|
if err := x.ServerStream.RecvMsg(m); err != nil {
|
|
return nil, err
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
func _Content_Abort_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(AbortRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ContentServer).Abort(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/containerd.services.content.v1.Content/Abort",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ContentServer).Abort(ctx, req.(*AbortRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
// Content_ServiceDesc is the grpc.ServiceDesc for Content service.
|
|
// It's only intended for direct use with grpc.RegisterService,
|
|
// and not to be introspected or modified (even as a copy)
|
|
var Content_ServiceDesc = grpc.ServiceDesc{
|
|
ServiceName: "containerd.services.content.v1.Content",
|
|
HandlerType: (*ContentServer)(nil),
|
|
Methods: []grpc.MethodDesc{
|
|
{
|
|
MethodName: "Info",
|
|
Handler: _Content_Info_Handler,
|
|
},
|
|
{
|
|
MethodName: "Update",
|
|
Handler: _Content_Update_Handler,
|
|
},
|
|
{
|
|
MethodName: "Delete",
|
|
Handler: _Content_Delete_Handler,
|
|
},
|
|
{
|
|
MethodName: "Status",
|
|
Handler: _Content_Status_Handler,
|
|
},
|
|
{
|
|
MethodName: "ListStatuses",
|
|
Handler: _Content_ListStatuses_Handler,
|
|
},
|
|
{
|
|
MethodName: "Abort",
|
|
Handler: _Content_Abort_Handler,
|
|
},
|
|
},
|
|
Streams: []grpc.StreamDesc{
|
|
{
|
|
StreamName: "List",
|
|
Handler: _Content_List_Handler,
|
|
ServerStreams: true,
|
|
},
|
|
{
|
|
StreamName: "Read",
|
|
Handler: _Content_Read_Handler,
|
|
ServerStreams: true,
|
|
},
|
|
{
|
|
StreamName: "Write",
|
|
Handler: _Content_Write_Handler,
|
|
ServerStreams: true,
|
|
ClientStreams: true,
|
|
},
|
|
},
|
|
Metadata: "github.com/containerd/containerd/api/services/content/v1/content.proto",
|
|
}
|