From 4445d0a8da4fde83804a533fe815847234ff109e Mon Sep 17 00:00:00 2001 From: Maksym Pavlenko Date: Mon, 19 Apr 2021 15:08:31 -0700 Subject: [PATCH] [sandbox] Add protobuf definitions Signed-off-by: Maksym Pavlenko --- api/next.pb.txt | 442 ++- api/services/sandbox/v1/sandbox.pb.go | 4609 +++++++++++++++++++++++++ api/services/sandbox/v1/sandbox.proto | 132 + api/types/sandbox.pb.go | 1147 ++++++ api/types/sandbox.proto | 51 + runtime/v2/task/sandbox.pb.go | 2972 ++++++++++++++++ runtime/v2/task/sandbox.proto | 98 + 7 files changed, 9447 insertions(+), 4 deletions(-) create mode 100644 api/services/sandbox/v1/sandbox.pb.go create mode 100644 api/services/sandbox/v1/sandbox.proto create mode 100644 api/types/sandbox.pb.go create mode 100644 api/types/sandbox.proto create mode 100644 runtime/v2/task/sandbox.pb.go create mode 100644 runtime/v2/task/sandbox.proto diff --git a/api/next.pb.txt b/api/next.pb.txt index 4e8b3041c..98b74e017 100644 --- a/api/next.pb.txt +++ b/api/next.pb.txt @@ -22,7 +22,7 @@ file { java_package: "com.google.protobuf" java_outer_classname: "AnyProto" java_multiple_files: true - go_package: "github.com/golang/protobuf/ptypes/any" + go_package: "google.golang.org/protobuf/types/known/anypb" objc_class_prefix: "GPB" csharp_namespace: "Google.Protobuf.WellKnownTypes" } @@ -458,7 +458,7 @@ file { java_package: "com.google.protobuf" java_outer_classname: "TimestampProto" java_multiple_files: true - go_package: "github.com/golang/protobuf/ptypes/timestamp" + go_package: "google.golang.org/protobuf/types/known/timestamppb" cc_enable_arenas: true objc_class_prefix: "GPB" csharp_namespace: "Google.Protobuf.WellKnownTypes" @@ -800,7 +800,7 @@ file { java_package: "com.google.protobuf" java_outer_classname: "EmptyProto" java_multiple_files: true - go_package: "github.com/golang/protobuf/ptypes/empty" + go_package: "google.golang.org/protobuf/types/known/emptypb" cc_enable_arenas: true objc_class_prefix: "GPB" csharp_namespace: "Google.Protobuf.WellKnownTypes" @@ -824,7 +824,7 @@ file { java_package: "com.google.protobuf" java_outer_classname: "FieldMaskProto" java_multiple_files: true - go_package: "google.golang.org/genproto/protobuf/field_mask;field_mask" + go_package: "google.golang.org/protobuf/types/known/fieldmaskpb" cc_enable_arenas: true objc_class_prefix: "GPB" csharp_namespace: "Google.Protobuf.WellKnownTypes" @@ -2929,6 +2929,440 @@ file { } syntax: "proto3" } +file { + name: "github.com/containerd/containerd/api/types/sandbox.proto" + package: "containerd.types" + dependency: "gogoproto/gogo.proto" + dependency: "google/protobuf/any.proto" + dependency: "google/protobuf/timestamp.proto" + message_type { + name: "Sandbox" + field { + name: "sandbox_id" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_STRING + json_name: "sandboxId" + } + field { + name: "runtime" + number: 2 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".containerd.types.Sandbox.Runtime" + options { + 65001: 0 + } + json_name: "runtime" + } + field { + name: "spec" + number: 3 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.protobuf.Any" + json_name: "spec" + } + field { + name: "labels" + number: 4 + label: LABEL_REPEATED + type: TYPE_MESSAGE + type_name: ".containerd.types.Sandbox.LabelsEntry" + options { + 65001: 0 + } + json_name: "labels" + } + field { + name: "created_at" + number: 5 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.protobuf.Timestamp" + options { + 65001: 0 + 65010: 1 + } + json_name: "createdAt" + } + field { + name: "updated_at" + number: 6 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.protobuf.Timestamp" + options { + 65001: 0 + 65010: 1 + } + json_name: "updatedAt" + } + field { + name: "extensions" + number: 7 + label: LABEL_REPEATED + type: TYPE_MESSAGE + type_name: ".containerd.types.Sandbox.ExtensionsEntry" + options { + 65001: 0 + } + json_name: "extensions" + } + nested_type { + name: "Runtime" + field { + name: "name" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_STRING + json_name: "name" + } + field { + name: "options" + number: 2 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.protobuf.Any" + json_name: "options" + } + } + nested_type { + name: "LabelsEntry" + field { + name: "key" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_STRING + json_name: "key" + } + field { + name: "value" + number: 2 + label: LABEL_OPTIONAL + type: TYPE_STRING + json_name: "value" + } + options { + map_entry: true + } + } + nested_type { + name: "ExtensionsEntry" + field { + name: "key" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_STRING + json_name: "key" + } + field { + name: "value" + number: 2 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.protobuf.Any" + json_name: "value" + } + options { + map_entry: true + } + } + } + options { + go_package: "github.com/containerd/containerd/api/types;types" + } + weak_dependency: 0 + syntax: "proto3" +} +file { + name: "github.com/containerd/containerd/api/services/sandbox/v1/sandbox.proto" + package: "containerd.services.sandbox.v1" + dependency: "gogoproto/gogo.proto" + dependency: "google/protobuf/any.proto" + dependency: "github.com/containerd/containerd/api/types/sandbox.proto" + message_type { + name: "StoreCreateRequest" + field { + name: "sandbox" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".containerd.types.Sandbox" + options { + 65001: 0 + } + json_name: "sandbox" + } + } + message_type { + name: "StoreCreateResponse" + field { + name: "sandbox" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".containerd.types.Sandbox" + options { + 65001: 0 + } + json_name: "sandbox" + } + } + message_type { + name: "StoreUpdateRequest" + field { + name: "sandbox" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".containerd.types.Sandbox" + options { + 65001: 0 + } + json_name: "sandbox" + } + field { + name: "fields" + number: 2 + label: LABEL_REPEATED + type: TYPE_STRING + json_name: "fields" + } + } + message_type { + name: "StoreUpdateResponse" + field { + name: "sandbox" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".containerd.types.Sandbox" + options { + 65001: 0 + } + json_name: "sandbox" + } + } + message_type { + name: "StoreDeleteRequest" + field { + name: "sandbox_id" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_STRING + json_name: "sandboxId" + } + } + message_type { + name: "StoreDeleteResponse" + } + message_type { + name: "StoreListRequest" + field { + name: "filters" + number: 1 + label: LABEL_REPEATED + type: TYPE_STRING + json_name: "filters" + } + } + message_type { + name: "StoreListResponse" + field { + name: "list" + number: 1 + label: LABEL_REPEATED + type: TYPE_MESSAGE + type_name: ".containerd.types.Sandbox" + options { + 65001: 0 + } + json_name: "list" + } + } + message_type { + name: "StoreGetRequest" + field { + name: "sandbox_id" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_STRING + json_name: "sandboxId" + } + } + message_type { + name: "StoreGetResponse" + field { + name: "sandbox" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".containerd.types.Sandbox" + json_name: "sandbox" + } + } + message_type { + name: "ControllerStartRequest" + field { + name: "sandbox_id" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_STRING + json_name: "sandboxId" + } + field { + name: "spec" + number: 4 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.protobuf.Any" + json_name: "spec" + } + } + message_type { + name: "ControllerStartResponse" + } + message_type { + name: "ControllerShutdownRequest" + field { + name: "sandbox_id" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_STRING + json_name: "sandboxId" + } + } + message_type { + name: "ControllerShutdownResponse" + } + message_type { + name: "ControllerPauseRequest" + field { + name: "sandbox_id" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_STRING + json_name: "sandboxId" + } + } + message_type { + name: "ControllerPauseResponse" + } + message_type { + name: "ControllerResumeRequest" + field { + name: "sandbox_id" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_STRING + json_name: "sandboxId" + } + } + message_type { + name: "ControllerResumeResponse" + } + message_type { + name: "ControllerPingRequest" + field { + name: "sandbox_id" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_STRING + json_name: "sandboxId" + } + } + message_type { + name: "ControllerPingResponse" + } + message_type { + name: "ControllerStatusRequest" + field { + name: "sandbox_id" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_STRING + json_name: "sandboxId" + } + } + message_type { + name: "ControllerStatusResponse" + field { + name: "status" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.protobuf.Any" + json_name: "status" + } + } + service { + name: "Store" + method { + name: "Create" + input_type: ".containerd.services.sandbox.v1.StoreCreateRequest" + output_type: ".containerd.services.sandbox.v1.StoreCreateResponse" + } + method { + name: "Update" + input_type: ".containerd.services.sandbox.v1.StoreUpdateRequest" + output_type: ".containerd.services.sandbox.v1.StoreUpdateResponse" + } + method { + name: "Delete" + input_type: ".containerd.services.sandbox.v1.StoreDeleteRequest" + output_type: ".containerd.services.sandbox.v1.StoreDeleteResponse" + } + method { + name: "List" + input_type: ".containerd.services.sandbox.v1.StoreListRequest" + output_type: ".containerd.services.sandbox.v1.StoreListResponse" + } + method { + name: "Get" + input_type: ".containerd.services.sandbox.v1.StoreGetRequest" + output_type: ".containerd.services.sandbox.v1.StoreGetResponse" + } + } + service { + name: "Controller" + method { + name: "Start" + input_type: ".containerd.services.sandbox.v1.ControllerStartRequest" + output_type: ".containerd.services.sandbox.v1.ControllerStartResponse" + } + method { + name: "Shutdown" + input_type: ".containerd.services.sandbox.v1.ControllerShutdownRequest" + output_type: ".containerd.services.sandbox.v1.ControllerShutdownResponse" + } + method { + name: "Pause" + input_type: ".containerd.services.sandbox.v1.ControllerPauseRequest" + output_type: ".containerd.services.sandbox.v1.ControllerPauseResponse" + } + method { + name: "Resume" + input_type: ".containerd.services.sandbox.v1.ControllerResumeRequest" + output_type: ".containerd.services.sandbox.v1.ControllerResumeResponse" + } + method { + name: "Ping" + input_type: ".containerd.services.sandbox.v1.ControllerPingRequest" + output_type: ".containerd.services.sandbox.v1.ControllerPingResponse" + } + method { + name: "Status" + input_type: ".containerd.services.sandbox.v1.ControllerStatusRequest" + output_type: ".containerd.services.sandbox.v1.ControllerStatusResponse" + } + } + options { + go_package: "github.com/containerd/containerd/api/services/sandbox/v1;sandbox" + } + weak_dependency: 0 + syntax: "proto3" +} file { name: "github.com/containerd/containerd/api/services/snapshots/v1/snapshots.proto" package: "containerd.services.snapshots.v1" diff --git a/api/services/sandbox/v1/sandbox.pb.go b/api/services/sandbox/v1/sandbox.pb.go new file mode 100644 index 000000000..76f099aea --- /dev/null +++ b/api/services/sandbox/v1/sandbox.pb.go @@ -0,0 +1,4609 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: github.com/containerd/containerd/api/services/sandbox/v1/sandbox.proto + +// Sandbox is a v2 runtime extension that allows more complex execution environments for containers. +// This adds a notion of groups of containers that share same lifecycle and/or resources. +// A few good fits for sandbox can be: +// - A "pause" container in k8s, that acts as a parent process for child containers to hold network namespace. +// - (micro)VMs that launch a VM process and executes containers inside guest OS. +// containerd in this case remains implementation agnostic and delegates sandbox handling to runtimes. +// See proposal and discussion here: https://github.com/containerd/containerd/issues/4131 + +package sandbox + +import ( + context "context" + fmt "fmt" + types "github.com/containerd/containerd/api/types" + proto "github.com/gogo/protobuf/proto" + types1 "github.com/gogo/protobuf/types" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + io "io" + math "math" + math_bits "math/bits" + reflect "reflect" + strings "strings" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type StoreCreateRequest struct { + Sandbox types.Sandbox `protobuf:"bytes,1,opt,name=sandbox,proto3" json:"sandbox"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *StoreCreateRequest) Reset() { *m = StoreCreateRequest{} } +func (*StoreCreateRequest) ProtoMessage() {} +func (*StoreCreateRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_d6eb1ebcbc2879f1, []int{0} +} +func (m *StoreCreateRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StoreCreateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StoreCreateRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *StoreCreateRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_StoreCreateRequest.Merge(m, src) +} +func (m *StoreCreateRequest) XXX_Size() int { + return m.Size() +} +func (m *StoreCreateRequest) XXX_DiscardUnknown() { + xxx_messageInfo_StoreCreateRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_StoreCreateRequest proto.InternalMessageInfo + +type StoreCreateResponse struct { + Sandbox types.Sandbox `protobuf:"bytes,1,opt,name=sandbox,proto3" json:"sandbox"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *StoreCreateResponse) Reset() { *m = StoreCreateResponse{} } +func (*StoreCreateResponse) ProtoMessage() {} +func (*StoreCreateResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_d6eb1ebcbc2879f1, []int{1} +} +func (m *StoreCreateResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StoreCreateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StoreCreateResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *StoreCreateResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_StoreCreateResponse.Merge(m, src) +} +func (m *StoreCreateResponse) XXX_Size() int { + return m.Size() +} +func (m *StoreCreateResponse) XXX_DiscardUnknown() { + xxx_messageInfo_StoreCreateResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_StoreCreateResponse proto.InternalMessageInfo + +type StoreUpdateRequest struct { + Sandbox types.Sandbox `protobuf:"bytes,1,opt,name=sandbox,proto3" json:"sandbox"` + Fields []string `protobuf:"bytes,2,rep,name=fields,proto3" json:"fields,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *StoreUpdateRequest) Reset() { *m = StoreUpdateRequest{} } +func (*StoreUpdateRequest) ProtoMessage() {} +func (*StoreUpdateRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_d6eb1ebcbc2879f1, []int{2} +} +func (m *StoreUpdateRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StoreUpdateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StoreUpdateRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *StoreUpdateRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_StoreUpdateRequest.Merge(m, src) +} +func (m *StoreUpdateRequest) XXX_Size() int { + return m.Size() +} +func (m *StoreUpdateRequest) XXX_DiscardUnknown() { + xxx_messageInfo_StoreUpdateRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_StoreUpdateRequest proto.InternalMessageInfo + +type StoreUpdateResponse struct { + Sandbox types.Sandbox `protobuf:"bytes,1,opt,name=sandbox,proto3" json:"sandbox"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *StoreUpdateResponse) Reset() { *m = StoreUpdateResponse{} } +func (*StoreUpdateResponse) ProtoMessage() {} +func (*StoreUpdateResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_d6eb1ebcbc2879f1, []int{3} +} +func (m *StoreUpdateResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StoreUpdateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StoreUpdateResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *StoreUpdateResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_StoreUpdateResponse.Merge(m, src) +} +func (m *StoreUpdateResponse) XXX_Size() int { + return m.Size() +} +func (m *StoreUpdateResponse) XXX_DiscardUnknown() { + xxx_messageInfo_StoreUpdateResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_StoreUpdateResponse proto.InternalMessageInfo + +type StoreDeleteRequest struct { + SandboxID string `protobuf:"bytes,1,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *StoreDeleteRequest) Reset() { *m = StoreDeleteRequest{} } +func (*StoreDeleteRequest) ProtoMessage() {} +func (*StoreDeleteRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_d6eb1ebcbc2879f1, []int{4} +} +func (m *StoreDeleteRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StoreDeleteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StoreDeleteRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *StoreDeleteRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_StoreDeleteRequest.Merge(m, src) +} +func (m *StoreDeleteRequest) XXX_Size() int { + return m.Size() +} +func (m *StoreDeleteRequest) XXX_DiscardUnknown() { + xxx_messageInfo_StoreDeleteRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_StoreDeleteRequest proto.InternalMessageInfo + +type StoreDeleteResponse struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *StoreDeleteResponse) Reset() { *m = StoreDeleteResponse{} } +func (*StoreDeleteResponse) ProtoMessage() {} +func (*StoreDeleteResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_d6eb1ebcbc2879f1, []int{5} +} +func (m *StoreDeleteResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StoreDeleteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StoreDeleteResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *StoreDeleteResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_StoreDeleteResponse.Merge(m, src) +} +func (m *StoreDeleteResponse) XXX_Size() int { + return m.Size() +} +func (m *StoreDeleteResponse) XXX_DiscardUnknown() { + xxx_messageInfo_StoreDeleteResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_StoreDeleteResponse proto.InternalMessageInfo + +type StoreListRequest struct { + Filters []string `protobuf:"bytes,1,rep,name=filters,proto3" json:"filters,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *StoreListRequest) Reset() { *m = StoreListRequest{} } +func (*StoreListRequest) ProtoMessage() {} +func (*StoreListRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_d6eb1ebcbc2879f1, []int{6} +} +func (m *StoreListRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StoreListRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StoreListRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *StoreListRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_StoreListRequest.Merge(m, src) +} +func (m *StoreListRequest) XXX_Size() int { + return m.Size() +} +func (m *StoreListRequest) XXX_DiscardUnknown() { + xxx_messageInfo_StoreListRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_StoreListRequest proto.InternalMessageInfo + +type StoreListResponse struct { + List []types.Sandbox `protobuf:"bytes,1,rep,name=list,proto3" json:"list"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *StoreListResponse) Reset() { *m = StoreListResponse{} } +func (*StoreListResponse) ProtoMessage() {} +func (*StoreListResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_d6eb1ebcbc2879f1, []int{7} +} +func (m *StoreListResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StoreListResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StoreListResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *StoreListResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_StoreListResponse.Merge(m, src) +} +func (m *StoreListResponse) XXX_Size() int { + return m.Size() +} +func (m *StoreListResponse) XXX_DiscardUnknown() { + xxx_messageInfo_StoreListResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_StoreListResponse proto.InternalMessageInfo + +type StoreGetRequest struct { + SandboxID string `protobuf:"bytes,1,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *StoreGetRequest) Reset() { *m = StoreGetRequest{} } +func (*StoreGetRequest) ProtoMessage() {} +func (*StoreGetRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_d6eb1ebcbc2879f1, []int{8} +} +func (m *StoreGetRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StoreGetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StoreGetRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *StoreGetRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_StoreGetRequest.Merge(m, src) +} +func (m *StoreGetRequest) XXX_Size() int { + return m.Size() +} +func (m *StoreGetRequest) XXX_DiscardUnknown() { + xxx_messageInfo_StoreGetRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_StoreGetRequest proto.InternalMessageInfo + +type StoreGetResponse struct { + Sandbox *types.Sandbox `protobuf:"bytes,1,opt,name=sandbox,proto3" json:"sandbox,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *StoreGetResponse) Reset() { *m = StoreGetResponse{} } +func (*StoreGetResponse) ProtoMessage() {} +func (*StoreGetResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_d6eb1ebcbc2879f1, []int{9} +} +func (m *StoreGetResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StoreGetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StoreGetResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *StoreGetResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_StoreGetResponse.Merge(m, src) +} +func (m *StoreGetResponse) XXX_Size() int { + return m.Size() +} +func (m *StoreGetResponse) XXX_DiscardUnknown() { + xxx_messageInfo_StoreGetResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_StoreGetResponse proto.InternalMessageInfo + +type ControllerStartRequest struct { + SandboxID string `protobuf:"bytes,1,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` + Spec *types1.Any `protobuf:"bytes,4,opt,name=spec,proto3" json:"spec,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ControllerStartRequest) Reset() { *m = ControllerStartRequest{} } +func (*ControllerStartRequest) ProtoMessage() {} +func (*ControllerStartRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_d6eb1ebcbc2879f1, []int{10} +} +func (m *ControllerStartRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ControllerStartRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ControllerStartRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ControllerStartRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ControllerStartRequest.Merge(m, src) +} +func (m *ControllerStartRequest) XXX_Size() int { + return m.Size() +} +func (m *ControllerStartRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ControllerStartRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ControllerStartRequest proto.InternalMessageInfo + +type ControllerStartResponse struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ControllerStartResponse) Reset() { *m = ControllerStartResponse{} } +func (*ControllerStartResponse) ProtoMessage() {} +func (*ControllerStartResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_d6eb1ebcbc2879f1, []int{11} +} +func (m *ControllerStartResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ControllerStartResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ControllerStartResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ControllerStartResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ControllerStartResponse.Merge(m, src) +} +func (m *ControllerStartResponse) XXX_Size() int { + return m.Size() +} +func (m *ControllerStartResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ControllerStartResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ControllerStartResponse proto.InternalMessageInfo + +type ControllerShutdownRequest struct { + SandboxID string `protobuf:"bytes,1,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ControllerShutdownRequest) Reset() { *m = ControllerShutdownRequest{} } +func (*ControllerShutdownRequest) ProtoMessage() {} +func (*ControllerShutdownRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_d6eb1ebcbc2879f1, []int{12} +} +func (m *ControllerShutdownRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ControllerShutdownRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ControllerShutdownRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ControllerShutdownRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ControllerShutdownRequest.Merge(m, src) +} +func (m *ControllerShutdownRequest) XXX_Size() int { + return m.Size() +} +func (m *ControllerShutdownRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ControllerShutdownRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ControllerShutdownRequest proto.InternalMessageInfo + +type ControllerShutdownResponse struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ControllerShutdownResponse) Reset() { *m = ControllerShutdownResponse{} } +func (*ControllerShutdownResponse) ProtoMessage() {} +func (*ControllerShutdownResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_d6eb1ebcbc2879f1, []int{13} +} +func (m *ControllerShutdownResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ControllerShutdownResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ControllerShutdownResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ControllerShutdownResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ControllerShutdownResponse.Merge(m, src) +} +func (m *ControllerShutdownResponse) XXX_Size() int { + return m.Size() +} +func (m *ControllerShutdownResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ControllerShutdownResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ControllerShutdownResponse proto.InternalMessageInfo + +type ControllerPauseRequest struct { + SandboxID string `protobuf:"bytes,1,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ControllerPauseRequest) Reset() { *m = ControllerPauseRequest{} } +func (*ControllerPauseRequest) ProtoMessage() {} +func (*ControllerPauseRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_d6eb1ebcbc2879f1, []int{14} +} +func (m *ControllerPauseRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ControllerPauseRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ControllerPauseRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ControllerPauseRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ControllerPauseRequest.Merge(m, src) +} +func (m *ControllerPauseRequest) XXX_Size() int { + return m.Size() +} +func (m *ControllerPauseRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ControllerPauseRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ControllerPauseRequest proto.InternalMessageInfo + +type ControllerPauseResponse struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ControllerPauseResponse) Reset() { *m = ControllerPauseResponse{} } +func (*ControllerPauseResponse) ProtoMessage() {} +func (*ControllerPauseResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_d6eb1ebcbc2879f1, []int{15} +} +func (m *ControllerPauseResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ControllerPauseResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ControllerPauseResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ControllerPauseResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ControllerPauseResponse.Merge(m, src) +} +func (m *ControllerPauseResponse) XXX_Size() int { + return m.Size() +} +func (m *ControllerPauseResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ControllerPauseResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ControllerPauseResponse proto.InternalMessageInfo + +type ControllerResumeRequest struct { + SandboxID string `protobuf:"bytes,1,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ControllerResumeRequest) Reset() { *m = ControllerResumeRequest{} } +func (*ControllerResumeRequest) ProtoMessage() {} +func (*ControllerResumeRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_d6eb1ebcbc2879f1, []int{16} +} +func (m *ControllerResumeRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ControllerResumeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ControllerResumeRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ControllerResumeRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ControllerResumeRequest.Merge(m, src) +} +func (m *ControllerResumeRequest) XXX_Size() int { + return m.Size() +} +func (m *ControllerResumeRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ControllerResumeRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ControllerResumeRequest proto.InternalMessageInfo + +type ControllerResumeResponse struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ControllerResumeResponse) Reset() { *m = ControllerResumeResponse{} } +func (*ControllerResumeResponse) ProtoMessage() {} +func (*ControllerResumeResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_d6eb1ebcbc2879f1, []int{17} +} +func (m *ControllerResumeResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ControllerResumeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ControllerResumeResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ControllerResumeResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ControllerResumeResponse.Merge(m, src) +} +func (m *ControllerResumeResponse) XXX_Size() int { + return m.Size() +} +func (m *ControllerResumeResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ControllerResumeResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ControllerResumeResponse proto.InternalMessageInfo + +type ControllerPingRequest struct { + SandboxID string `protobuf:"bytes,1,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ControllerPingRequest) Reset() { *m = ControllerPingRequest{} } +func (*ControllerPingRequest) ProtoMessage() {} +func (*ControllerPingRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_d6eb1ebcbc2879f1, []int{18} +} +func (m *ControllerPingRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ControllerPingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ControllerPingRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ControllerPingRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ControllerPingRequest.Merge(m, src) +} +func (m *ControllerPingRequest) XXX_Size() int { + return m.Size() +} +func (m *ControllerPingRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ControllerPingRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ControllerPingRequest proto.InternalMessageInfo + +type ControllerPingResponse struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ControllerPingResponse) Reset() { *m = ControllerPingResponse{} } +func (*ControllerPingResponse) ProtoMessage() {} +func (*ControllerPingResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_d6eb1ebcbc2879f1, []int{19} +} +func (m *ControllerPingResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ControllerPingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ControllerPingResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ControllerPingResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ControllerPingResponse.Merge(m, src) +} +func (m *ControllerPingResponse) XXX_Size() int { + return m.Size() +} +func (m *ControllerPingResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ControllerPingResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ControllerPingResponse proto.InternalMessageInfo + +type ControllerStatusRequest struct { + SandboxID string `protobuf:"bytes,1,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ControllerStatusRequest) Reset() { *m = ControllerStatusRequest{} } +func (*ControllerStatusRequest) ProtoMessage() {} +func (*ControllerStatusRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_d6eb1ebcbc2879f1, []int{20} +} +func (m *ControllerStatusRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ControllerStatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ControllerStatusRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ControllerStatusRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ControllerStatusRequest.Merge(m, src) +} +func (m *ControllerStatusRequest) XXX_Size() int { + return m.Size() +} +func (m *ControllerStatusRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ControllerStatusRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ControllerStatusRequest proto.InternalMessageInfo + +type ControllerStatusResponse struct { + Status *types1.Any `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ControllerStatusResponse) Reset() { *m = ControllerStatusResponse{} } +func (*ControllerStatusResponse) ProtoMessage() {} +func (*ControllerStatusResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_d6eb1ebcbc2879f1, []int{21} +} +func (m *ControllerStatusResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ControllerStatusResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ControllerStatusResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ControllerStatusResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ControllerStatusResponse.Merge(m, src) +} +func (m *ControllerStatusResponse) XXX_Size() int { + return m.Size() +} +func (m *ControllerStatusResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ControllerStatusResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ControllerStatusResponse proto.InternalMessageInfo + +func init() { + proto.RegisterType((*StoreCreateRequest)(nil), "containerd.services.sandbox.v1.StoreCreateRequest") + proto.RegisterType((*StoreCreateResponse)(nil), "containerd.services.sandbox.v1.StoreCreateResponse") + proto.RegisterType((*StoreUpdateRequest)(nil), "containerd.services.sandbox.v1.StoreUpdateRequest") + proto.RegisterType((*StoreUpdateResponse)(nil), "containerd.services.sandbox.v1.StoreUpdateResponse") + proto.RegisterType((*StoreDeleteRequest)(nil), "containerd.services.sandbox.v1.StoreDeleteRequest") + proto.RegisterType((*StoreDeleteResponse)(nil), "containerd.services.sandbox.v1.StoreDeleteResponse") + proto.RegisterType((*StoreListRequest)(nil), "containerd.services.sandbox.v1.StoreListRequest") + proto.RegisterType((*StoreListResponse)(nil), "containerd.services.sandbox.v1.StoreListResponse") + proto.RegisterType((*StoreGetRequest)(nil), "containerd.services.sandbox.v1.StoreGetRequest") + proto.RegisterType((*StoreGetResponse)(nil), "containerd.services.sandbox.v1.StoreGetResponse") + proto.RegisterType((*ControllerStartRequest)(nil), "containerd.services.sandbox.v1.ControllerStartRequest") + proto.RegisterType((*ControllerStartResponse)(nil), "containerd.services.sandbox.v1.ControllerStartResponse") + proto.RegisterType((*ControllerShutdownRequest)(nil), "containerd.services.sandbox.v1.ControllerShutdownRequest") + proto.RegisterType((*ControllerShutdownResponse)(nil), "containerd.services.sandbox.v1.ControllerShutdownResponse") + proto.RegisterType((*ControllerPauseRequest)(nil), "containerd.services.sandbox.v1.ControllerPauseRequest") + proto.RegisterType((*ControllerPauseResponse)(nil), "containerd.services.sandbox.v1.ControllerPauseResponse") + proto.RegisterType((*ControllerResumeRequest)(nil), "containerd.services.sandbox.v1.ControllerResumeRequest") + proto.RegisterType((*ControllerResumeResponse)(nil), "containerd.services.sandbox.v1.ControllerResumeResponse") + proto.RegisterType((*ControllerPingRequest)(nil), "containerd.services.sandbox.v1.ControllerPingRequest") + proto.RegisterType((*ControllerPingResponse)(nil), "containerd.services.sandbox.v1.ControllerPingResponse") + proto.RegisterType((*ControllerStatusRequest)(nil), "containerd.services.sandbox.v1.ControllerStatusRequest") + proto.RegisterType((*ControllerStatusResponse)(nil), "containerd.services.sandbox.v1.ControllerStatusResponse") +} + +func init() { + proto.RegisterFile("github.com/containerd/containerd/api/services/sandbox/v1/sandbox.proto", fileDescriptor_d6eb1ebcbc2879f1) +} + +var fileDescriptor_d6eb1ebcbc2879f1 = []byte{ + // 730 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0x4d, 0x4f, 0xd4, 0x40, + 0x18, 0xde, 0xca, 0x52, 0xdc, 0xd7, 0x18, 0x75, 0x04, 0xec, 0x36, 0xa6, 0x90, 0x9e, 0x38, 0x90, + 0x16, 0x96, 0x88, 0xa0, 0x07, 0x75, 0x41, 0x16, 0x12, 0x13, 0xc9, 0x6e, 0x4c, 0x0c, 0x17, 0xd3, + 0xdd, 0x0e, 0xa5, 0xb1, 0x74, 0xba, 0x9d, 0x29, 0x42, 0xbc, 0xe8, 0xaf, 0xf2, 0x2f, 0x70, 0xf4, + 0xe8, 0x89, 0xc8, 0xfe, 0x07, 0xef, 0x66, 0xa7, 0x53, 0xda, 0xca, 0x46, 0xdb, 0xe2, 0x6d, 0xba, + 0x7d, 0xde, 0xe7, 0x63, 0x78, 0xf7, 0x61, 0x61, 0xc7, 0x71, 0xd9, 0x51, 0xd4, 0x37, 0x06, 0xe4, + 0xd8, 0x1c, 0x10, 0x9f, 0x59, 0xae, 0x8f, 0x43, 0x3b, 0x7b, 0xb4, 0x02, 0xd7, 0xa4, 0x38, 0x3c, + 0x71, 0x07, 0x98, 0x9a, 0xd4, 0xf2, 0xed, 0x3e, 0x39, 0x35, 0x4f, 0x56, 0x93, 0xa3, 0x11, 0x84, + 0x84, 0x11, 0xa4, 0xa5, 0x13, 0x46, 0x82, 0x36, 0x12, 0xc8, 0xc9, 0xaa, 0x3a, 0xeb, 0x10, 0x87, + 0x70, 0xa8, 0x39, 0x3e, 0xc5, 0x53, 0x6a, 0xd3, 0x21, 0xc4, 0xf1, 0xb0, 0xc9, 0x9f, 0xfa, 0xd1, + 0xa1, 0x69, 0xf9, 0x67, 0xe2, 0xd5, 0x46, 0x21, 0x63, 0xec, 0x2c, 0x48, 0x5d, 0xc5, 0x93, 0xfa, + 0x5b, 0x40, 0x3d, 0x46, 0x42, 0xbc, 0x15, 0x62, 0x8b, 0xe1, 0x2e, 0x1e, 0x46, 0x98, 0x32, 0xb4, + 0x09, 0x33, 0x02, 0xa6, 0x48, 0x8b, 0xd2, 0xd2, 0x9d, 0x56, 0xd3, 0xc8, 0x58, 0xe6, 0x3c, 0x46, + 0x2f, 0x06, 0xb4, 0xeb, 0xe7, 0x17, 0x0b, 0xb5, 0x6e, 0x82, 0xd7, 0xf7, 0xe1, 0x61, 0x8e, 0x90, + 0x06, 0xc4, 0xa7, 0xf8, 0x26, 0x8c, 0x8e, 0xb0, 0xf8, 0x2e, 0xb0, 0xff, 0x8b, 0x45, 0x34, 0x0f, + 0xf2, 0xa1, 0x8b, 0x3d, 0x9b, 0x2a, 0xb7, 0x16, 0xa7, 0x96, 0x1a, 0x5d, 0xf1, 0x74, 0x65, 0x3d, + 0x11, 0xba, 0xb9, 0xf5, 0xb6, 0xb0, 0xbe, 0x8d, 0x3d, 0x9c, 0x5a, 0x5f, 0x06, 0x10, 0x80, 0x0f, + 0xae, 0xcd, 0x39, 0x1b, 0xed, 0xbb, 0xa3, 0x8b, 0x85, 0x86, 0x60, 0xd9, 0xdb, 0xee, 0x36, 0x04, + 0x60, 0xcf, 0xd6, 0xe7, 0x84, 0xab, 0x84, 0x23, 0x76, 0xa5, 0x2f, 0xc3, 0x7d, 0xfe, 0xf1, 0x1b, + 0x97, 0xb2, 0x84, 0x58, 0x81, 0x99, 0x43, 0xd7, 0x63, 0x38, 0xa4, 0x8a, 0xc4, 0x93, 0x25, 0x8f, + 0xfa, 0x2e, 0x3c, 0xc8, 0xa0, 0x45, 0xb0, 0x35, 0xa8, 0x7b, 0x2e, 0x65, 0x1c, 0x5b, 0x20, 0x15, + 0x07, 0xeb, 0x2f, 0xe0, 0x1e, 0x67, 0xea, 0x60, 0x56, 0x2d, 0x4f, 0x47, 0x18, 0xe7, 0x04, 0x57, + 0x4e, 0x0a, 0x5f, 0x71, 0x7a, 0xb9, 0x01, 0xcc, 0x6f, 0x11, 0x9f, 0x85, 0xc4, 0xf3, 0x70, 0xd8, + 0x63, 0x56, 0x58, 0xcd, 0x10, 0x5a, 0x82, 0x3a, 0x0d, 0xf0, 0x40, 0xa9, 0x73, 0xe5, 0x59, 0x23, + 0xfe, 0x9a, 0x19, 0xc9, 0xd7, 0xcc, 0x78, 0xe5, 0x9f, 0x75, 0x39, 0x42, 0x6f, 0xc2, 0xa3, 0x6b, + 0x8a, 0xe2, 0xcf, 0xb1, 0x07, 0xcd, 0xcc, 0xab, 0xa3, 0x88, 0xd9, 0xe4, 0x93, 0x5f, 0xed, 0x82, + 0x1e, 0x83, 0x3a, 0x89, 0x4a, 0x08, 0xed, 0x64, 0x53, 0xef, 0x5b, 0x11, 0xad, 0xb8, 0x56, 0xb9, + 0x2c, 0x82, 0x47, 0x48, 0x74, 0xb2, 0xaf, 0xba, 0x98, 0x46, 0xc7, 0x15, 0x35, 0x54, 0x50, 0xae, + 0x13, 0x09, 0x91, 0xd7, 0x30, 0x97, 0xd1, 0x77, 0x7d, 0xa7, 0x9a, 0x84, 0x92, 0xbb, 0x0e, 0x4e, + 0x33, 0x29, 0x45, 0x8f, 0x59, 0x2c, 0xa2, 0xd5, 0x24, 0x76, 0xb3, 0x29, 0x12, 0x22, 0xb1, 0xb8, + 0xcb, 0x20, 0x53, 0xfe, 0x89, 0xd8, 0xdb, 0xc9, 0xdb, 0x23, 0x30, 0xad, 0x6f, 0x75, 0x98, 0xe6, + 0xbb, 0x8f, 0x86, 0x20, 0xc7, 0x05, 0x89, 0x5a, 0xc6, 0xdf, 0xff, 0x19, 0x18, 0xd7, 0xeb, 0x59, + 0x5d, 0x2b, 0x35, 0x23, 0xac, 0x0e, 0x41, 0x8e, 0x8b, 0xad, 0xa0, 0x64, 0xae, 0x6e, 0x0b, 0x4a, + 0xfe, 0xd1, 0x9c, 0x43, 0x90, 0xe3, 0xd6, 0x2a, 0x28, 0x99, 0xab, 0xc9, 0x82, 0x92, 0xf9, 0x5a, + 0x44, 0x1f, 0xa1, 0x3e, 0xee, 0x38, 0xb4, 0x52, 0x68, 0x38, 0x53, 0x9e, 0xea, 0x6a, 0x89, 0x09, + 0x21, 0x76, 0x04, 0x53, 0x1d, 0xcc, 0x90, 0x59, 0x68, 0x32, 0x2d, 0x4c, 0x75, 0xa5, 0xf8, 0x40, + 0xac, 0xd4, 0xfa, 0x35, 0x0d, 0x90, 0x2e, 0x21, 0x3a, 0x1d, 0xef, 0x91, 0x15, 0x32, 0xb4, 0xfe, + 0x2f, 0xa6, 0xc9, 0x0d, 0xa9, 0x3e, 0x2d, 0x3d, 0x27, 0x22, 0x7f, 0x95, 0xe0, 0x76, 0xd2, 0x49, + 0x68, 0xb3, 0x04, 0x4b, 0xbe, 0x12, 0xd5, 0x67, 0x55, 0x46, 0x85, 0x87, 0x53, 0x98, 0xe6, 0x85, + 0x55, 0x26, 0x7d, 0xb6, 0x29, 0xcb, 0xa4, 0xcf, 0x35, 0x23, 0xfa, 0x0c, 0x72, 0x5c, 0x63, 0xa8, + 0x04, 0x45, 0xae, 0x41, 0xd5, 0x8d, 0xf2, 0x83, 0x42, 0x3c, 0x82, 0xfa, 0xb8, 0xe0, 0xd0, 0x93, + 0x12, 0xee, 0xd3, 0x5e, 0x55, 0xd7, 0xcb, 0x8e, 0xa5, 0x99, 0xe3, 0xd2, 0x43, 0xe5, 0x96, 0x26, + 0xed, 0xdb, 0x32, 0x99, 0xf3, 0xfd, 0xda, 0x3e, 0x38, 0xbf, 0xd4, 0x6a, 0x3f, 0x2e, 0xb5, 0xda, + 0x97, 0x91, 0x26, 0x9d, 0x8f, 0x34, 0xe9, 0xfb, 0x48, 0x93, 0x7e, 0x8e, 0x34, 0xe9, 0xe0, 0x65, + 0xd5, 0xdf, 0xe2, 0xcf, 0xc5, 0xf1, 0x7d, 0xad, 0x2f, 0xf3, 0x96, 0x5e, 0xfb, 0x1d, 0x00, 0x00, + 0xff, 0xff, 0x94, 0xa8, 0x1b, 0x82, 0xd8, 0x0b, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// StoreClient is the client API for Store service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type StoreClient interface { + Create(ctx context.Context, in *StoreCreateRequest, opts ...grpc.CallOption) (*StoreCreateResponse, error) + Update(ctx context.Context, in *StoreUpdateRequest, opts ...grpc.CallOption) (*StoreUpdateResponse, error) + Delete(ctx context.Context, in *StoreDeleteRequest, opts ...grpc.CallOption) (*StoreDeleteResponse, error) + List(ctx context.Context, in *StoreListRequest, opts ...grpc.CallOption) (*StoreListResponse, error) + Get(ctx context.Context, in *StoreGetRequest, opts ...grpc.CallOption) (*StoreGetResponse, error) +} + +type storeClient struct { + cc *grpc.ClientConn +} + +func NewStoreClient(cc *grpc.ClientConn) StoreClient { + return &storeClient{cc} +} + +func (c *storeClient) Create(ctx context.Context, in *StoreCreateRequest, opts ...grpc.CallOption) (*StoreCreateResponse, error) { + out := new(StoreCreateResponse) + err := c.cc.Invoke(ctx, "/containerd.services.sandbox.v1.Store/Create", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *storeClient) Update(ctx context.Context, in *StoreUpdateRequest, opts ...grpc.CallOption) (*StoreUpdateResponse, error) { + out := new(StoreUpdateResponse) + err := c.cc.Invoke(ctx, "/containerd.services.sandbox.v1.Store/Update", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *storeClient) Delete(ctx context.Context, in *StoreDeleteRequest, opts ...grpc.CallOption) (*StoreDeleteResponse, error) { + out := new(StoreDeleteResponse) + err := c.cc.Invoke(ctx, "/containerd.services.sandbox.v1.Store/Delete", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *storeClient) List(ctx context.Context, in *StoreListRequest, opts ...grpc.CallOption) (*StoreListResponse, error) { + out := new(StoreListResponse) + err := c.cc.Invoke(ctx, "/containerd.services.sandbox.v1.Store/List", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *storeClient) Get(ctx context.Context, in *StoreGetRequest, opts ...grpc.CallOption) (*StoreGetResponse, error) { + out := new(StoreGetResponse) + err := c.cc.Invoke(ctx, "/containerd.services.sandbox.v1.Store/Get", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// StoreServer is the server API for Store service. +type StoreServer 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) +} + +// UnimplementedStoreServer can be embedded to have forward compatible implementations. +type UnimplementedStoreServer struct { +} + +func (*UnimplementedStoreServer) Create(ctx context.Context, req *StoreCreateRequest) (*StoreCreateResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Create not implemented") +} +func (*UnimplementedStoreServer) Update(ctx context.Context, req *StoreUpdateRequest) (*StoreUpdateResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Update not implemented") +} +func (*UnimplementedStoreServer) Delete(ctx context.Context, req *StoreDeleteRequest) (*StoreDeleteResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented") +} +func (*UnimplementedStoreServer) List(ctx context.Context, req *StoreListRequest) (*StoreListResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method List not implemented") +} +func (*UnimplementedStoreServer) Get(ctx context.Context, req *StoreGetRequest) (*StoreGetResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Get not implemented") +} + +func RegisterStoreServer(s *grpc.Server, srv StoreServer) { + s.RegisterService(&_Store_serviceDesc, srv) +} + +func _Store_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(StoreCreateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(StoreServer).Create(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.services.sandbox.v1.Store/Create", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(StoreServer).Create(ctx, req.(*StoreCreateRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Store_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(StoreUpdateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(StoreServer).Update(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.services.sandbox.v1.Store/Update", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(StoreServer).Update(ctx, req.(*StoreUpdateRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Store_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(StoreDeleteRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(StoreServer).Delete(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.services.sandbox.v1.Store/Delete", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(StoreServer).Delete(ctx, req.(*StoreDeleteRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Store_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(StoreListRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(StoreServer).List(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.services.sandbox.v1.Store/List", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(StoreServer).List(ctx, req.(*StoreListRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Store_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(StoreGetRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(StoreServer).Get(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.services.sandbox.v1.Store/Get", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(StoreServer).Get(ctx, req.(*StoreGetRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _Store_serviceDesc = grpc.ServiceDesc{ + ServiceName: "containerd.services.sandbox.v1.Store", + HandlerType: (*StoreServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Create", + Handler: _Store_Create_Handler, + }, + { + MethodName: "Update", + Handler: _Store_Update_Handler, + }, + { + MethodName: "Delete", + Handler: _Store_Delete_Handler, + }, + { + MethodName: "List", + Handler: _Store_List_Handler, + }, + { + MethodName: "Get", + Handler: _Store_Get_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "github.com/containerd/containerd/api/services/sandbox/v1/sandbox.proto", +} + +// ControllerClient is the client API for Controller service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type ControllerClient interface { + Start(ctx context.Context, in *ControllerStartRequest, opts ...grpc.CallOption) (*ControllerStartResponse, error) + Shutdown(ctx context.Context, in *ControllerShutdownRequest, opts ...grpc.CallOption) (*ControllerShutdownResponse, error) + Pause(ctx context.Context, in *ControllerPauseRequest, opts ...grpc.CallOption) (*ControllerPauseResponse, error) + Resume(ctx context.Context, in *ControllerResumeRequest, opts ...grpc.CallOption) (*ControllerResumeResponse, error) + Ping(ctx context.Context, in *ControllerPingRequest, opts ...grpc.CallOption) (*ControllerPingResponse, error) + Status(ctx context.Context, in *ControllerStatusRequest, opts ...grpc.CallOption) (*ControllerStatusResponse, error) +} + +type controllerClient struct { + cc *grpc.ClientConn +} + +func NewControllerClient(cc *grpc.ClientConn) ControllerClient { + return &controllerClient{cc} +} + +func (c *controllerClient) Start(ctx context.Context, in *ControllerStartRequest, opts ...grpc.CallOption) (*ControllerStartResponse, error) { + out := new(ControllerStartResponse) + err := c.cc.Invoke(ctx, "/containerd.services.sandbox.v1.Controller/Start", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *controllerClient) Shutdown(ctx context.Context, in *ControllerShutdownRequest, opts ...grpc.CallOption) (*ControllerShutdownResponse, error) { + out := new(ControllerShutdownResponse) + err := c.cc.Invoke(ctx, "/containerd.services.sandbox.v1.Controller/Shutdown", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *controllerClient) Pause(ctx context.Context, in *ControllerPauseRequest, opts ...grpc.CallOption) (*ControllerPauseResponse, error) { + out := new(ControllerPauseResponse) + err := c.cc.Invoke(ctx, "/containerd.services.sandbox.v1.Controller/Pause", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *controllerClient) Resume(ctx context.Context, in *ControllerResumeRequest, opts ...grpc.CallOption) (*ControllerResumeResponse, error) { + out := new(ControllerResumeResponse) + err := c.cc.Invoke(ctx, "/containerd.services.sandbox.v1.Controller/Resume", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *controllerClient) Ping(ctx context.Context, in *ControllerPingRequest, opts ...grpc.CallOption) (*ControllerPingResponse, error) { + out := new(ControllerPingResponse) + err := c.cc.Invoke(ctx, "/containerd.services.sandbox.v1.Controller/Ping", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *controllerClient) Status(ctx context.Context, in *ControllerStatusRequest, opts ...grpc.CallOption) (*ControllerStatusResponse, error) { + out := new(ControllerStatusResponse) + err := c.cc.Invoke(ctx, "/containerd.services.sandbox.v1.Controller/Status", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// ControllerServer is the server API for Controller service. +type ControllerServer interface { + Start(context.Context, *ControllerStartRequest) (*ControllerStartResponse, error) + Shutdown(context.Context, *ControllerShutdownRequest) (*ControllerShutdownResponse, error) + Pause(context.Context, *ControllerPauseRequest) (*ControllerPauseResponse, error) + Resume(context.Context, *ControllerResumeRequest) (*ControllerResumeResponse, error) + Ping(context.Context, *ControllerPingRequest) (*ControllerPingResponse, error) + Status(context.Context, *ControllerStatusRequest) (*ControllerStatusResponse, error) +} + +// UnimplementedControllerServer can be embedded to have forward compatible implementations. +type UnimplementedControllerServer struct { +} + +func (*UnimplementedControllerServer) Start(ctx context.Context, req *ControllerStartRequest) (*ControllerStartResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Start not implemented") +} +func (*UnimplementedControllerServer) Shutdown(ctx context.Context, req *ControllerShutdownRequest) (*ControllerShutdownResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Shutdown not implemented") +} +func (*UnimplementedControllerServer) Pause(ctx context.Context, req *ControllerPauseRequest) (*ControllerPauseResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Pause not implemented") +} +func (*UnimplementedControllerServer) Resume(ctx context.Context, req *ControllerResumeRequest) (*ControllerResumeResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Resume not implemented") +} +func (*UnimplementedControllerServer) Ping(ctx context.Context, req *ControllerPingRequest) (*ControllerPingResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Ping not implemented") +} +func (*UnimplementedControllerServer) Status(ctx context.Context, req *ControllerStatusRequest) (*ControllerStatusResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Status not implemented") +} + +func RegisterControllerServer(s *grpc.Server, srv ControllerServer) { + s.RegisterService(&_Controller_serviceDesc, srv) +} + +func _Controller_Start_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ControllerStartRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ControllerServer).Start(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.services.sandbox.v1.Controller/Start", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ControllerServer).Start(ctx, req.(*ControllerStartRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Controller_Shutdown_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ControllerShutdownRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ControllerServer).Shutdown(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.services.sandbox.v1.Controller/Shutdown", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ControllerServer).Shutdown(ctx, req.(*ControllerShutdownRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Controller_Pause_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ControllerPauseRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ControllerServer).Pause(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.services.sandbox.v1.Controller/Pause", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ControllerServer).Pause(ctx, req.(*ControllerPauseRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Controller_Resume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ControllerResumeRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ControllerServer).Resume(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.services.sandbox.v1.Controller/Resume", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ControllerServer).Resume(ctx, req.(*ControllerResumeRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Controller_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ControllerPingRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ControllerServer).Ping(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.services.sandbox.v1.Controller/Ping", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ControllerServer).Ping(ctx, req.(*ControllerPingRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Controller_Status_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ControllerStatusRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ControllerServer).Status(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.services.sandbox.v1.Controller/Status", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ControllerServer).Status(ctx, req.(*ControllerStatusRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _Controller_serviceDesc = grpc.ServiceDesc{ + ServiceName: "containerd.services.sandbox.v1.Controller", + HandlerType: (*ControllerServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Start", + Handler: _Controller_Start_Handler, + }, + { + MethodName: "Shutdown", + Handler: _Controller_Shutdown_Handler, + }, + { + MethodName: "Pause", + Handler: _Controller_Pause_Handler, + }, + { + MethodName: "Resume", + Handler: _Controller_Resume_Handler, + }, + { + MethodName: "Ping", + Handler: _Controller_Ping_Handler, + }, + { + MethodName: "Status", + Handler: _Controller_Status_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "github.com/containerd/containerd/api/services/sandbox/v1/sandbox.proto", +} + +func (m *StoreCreateRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StoreCreateRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StoreCreateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + { + size, err := m.Sandbox.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSandbox(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *StoreCreateResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StoreCreateResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StoreCreateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + { + size, err := m.Sandbox.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSandbox(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *StoreUpdateRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StoreUpdateRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StoreUpdateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Fields) > 0 { + for iNdEx := len(m.Fields) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Fields[iNdEx]) + copy(dAtA[i:], m.Fields[iNdEx]) + i = encodeVarintSandbox(dAtA, i, uint64(len(m.Fields[iNdEx]))) + i-- + dAtA[i] = 0x12 + } + } + { + size, err := m.Sandbox.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSandbox(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *StoreUpdateResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StoreUpdateResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StoreUpdateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + { + size, err := m.Sandbox.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSandbox(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *StoreDeleteRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StoreDeleteRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StoreDeleteRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.SandboxID) > 0 { + i -= len(m.SandboxID) + copy(dAtA[i:], m.SandboxID) + i = encodeVarintSandbox(dAtA, i, uint64(len(m.SandboxID))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *StoreDeleteResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StoreDeleteResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StoreDeleteResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + return len(dAtA) - i, nil +} + +func (m *StoreListRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StoreListRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StoreListRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Filters) > 0 { + for iNdEx := len(m.Filters) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Filters[iNdEx]) + copy(dAtA[i:], m.Filters[iNdEx]) + i = encodeVarintSandbox(dAtA, i, uint64(len(m.Filters[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *StoreListResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StoreListResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StoreListResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.List) > 0 { + for iNdEx := len(m.List) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.List[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSandbox(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *StoreGetRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StoreGetRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StoreGetRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.SandboxID) > 0 { + i -= len(m.SandboxID) + copy(dAtA[i:], m.SandboxID) + i = encodeVarintSandbox(dAtA, i, uint64(len(m.SandboxID))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *StoreGetResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StoreGetResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StoreGetResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.Sandbox != nil { + { + size, err := m.Sandbox.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSandbox(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ControllerStartRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ControllerStartRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ControllerStartRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.Spec != nil { + { + size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSandbox(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if len(m.SandboxID) > 0 { + i -= len(m.SandboxID) + copy(dAtA[i:], m.SandboxID) + i = encodeVarintSandbox(dAtA, i, uint64(len(m.SandboxID))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ControllerStartResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ControllerStartResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ControllerStartResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + return len(dAtA) - i, nil +} + +func (m *ControllerShutdownRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ControllerShutdownRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ControllerShutdownRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.SandboxID) > 0 { + i -= len(m.SandboxID) + copy(dAtA[i:], m.SandboxID) + i = encodeVarintSandbox(dAtA, i, uint64(len(m.SandboxID))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ControllerShutdownResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ControllerShutdownResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ControllerShutdownResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + return len(dAtA) - i, nil +} + +func (m *ControllerPauseRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ControllerPauseRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ControllerPauseRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.SandboxID) > 0 { + i -= len(m.SandboxID) + copy(dAtA[i:], m.SandboxID) + i = encodeVarintSandbox(dAtA, i, uint64(len(m.SandboxID))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ControllerPauseResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ControllerPauseResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ControllerPauseResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + return len(dAtA) - i, nil +} + +func (m *ControllerResumeRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ControllerResumeRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ControllerResumeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.SandboxID) > 0 { + i -= len(m.SandboxID) + copy(dAtA[i:], m.SandboxID) + i = encodeVarintSandbox(dAtA, i, uint64(len(m.SandboxID))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ControllerResumeResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ControllerResumeResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ControllerResumeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + return len(dAtA) - i, nil +} + +func (m *ControllerPingRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ControllerPingRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ControllerPingRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.SandboxID) > 0 { + i -= len(m.SandboxID) + copy(dAtA[i:], m.SandboxID) + i = encodeVarintSandbox(dAtA, i, uint64(len(m.SandboxID))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ControllerPingResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ControllerPingResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ControllerPingResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + return len(dAtA) - i, nil +} + +func (m *ControllerStatusRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ControllerStatusRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ControllerStatusRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.SandboxID) > 0 { + i -= len(m.SandboxID) + copy(dAtA[i:], m.SandboxID) + i = encodeVarintSandbox(dAtA, i, uint64(len(m.SandboxID))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ControllerStatusResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ControllerStatusResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ControllerStatusResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.Status != nil { + { + size, err := m.Status.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSandbox(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintSandbox(dAtA []byte, offset int, v uint64) int { + offset -= sovSandbox(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *StoreCreateRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Sandbox.Size() + n += 1 + l + sovSandbox(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *StoreCreateResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Sandbox.Size() + n += 1 + l + sovSandbox(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *StoreUpdateRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Sandbox.Size() + n += 1 + l + sovSandbox(uint64(l)) + if len(m.Fields) > 0 { + for _, s := range m.Fields { + l = len(s) + n += 1 + l + sovSandbox(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *StoreUpdateResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Sandbox.Size() + n += 1 + l + sovSandbox(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *StoreDeleteRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.SandboxID) + if l > 0 { + n += 1 + l + sovSandbox(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *StoreDeleteResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *StoreListRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Filters) > 0 { + for _, s := range m.Filters { + l = len(s) + n += 1 + l + sovSandbox(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *StoreListResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.List) > 0 { + for _, e := range m.List { + l = e.Size() + n += 1 + l + sovSandbox(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *StoreGetRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.SandboxID) + if l > 0 { + n += 1 + l + sovSandbox(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *StoreGetResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Sandbox != nil { + l = m.Sandbox.Size() + n += 1 + l + sovSandbox(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ControllerStartRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.SandboxID) + if l > 0 { + n += 1 + l + sovSandbox(uint64(l)) + } + if m.Spec != nil { + l = m.Spec.Size() + n += 1 + l + sovSandbox(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ControllerStartResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ControllerShutdownRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.SandboxID) + if l > 0 { + n += 1 + l + sovSandbox(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ControllerShutdownResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ControllerPauseRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.SandboxID) + if l > 0 { + n += 1 + l + sovSandbox(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ControllerPauseResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ControllerResumeRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.SandboxID) + if l > 0 { + n += 1 + l + sovSandbox(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ControllerResumeResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ControllerPingRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.SandboxID) + if l > 0 { + n += 1 + l + sovSandbox(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ControllerPingResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ControllerStatusRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.SandboxID) + if l > 0 { + n += 1 + l + sovSandbox(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ControllerStatusResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Status != nil { + l = m.Status.Size() + n += 1 + l + sovSandbox(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovSandbox(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozSandbox(x uint64) (n int) { + return sovSandbox(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *StoreCreateRequest) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&StoreCreateRequest{`, + `Sandbox:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Sandbox), "Sandbox", "types.Sandbox", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *StoreCreateResponse) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&StoreCreateResponse{`, + `Sandbox:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Sandbox), "Sandbox", "types.Sandbox", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *StoreUpdateRequest) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&StoreUpdateRequest{`, + `Sandbox:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Sandbox), "Sandbox", "types.Sandbox", 1), `&`, ``, 1) + `,`, + `Fields:` + fmt.Sprintf("%v", this.Fields) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *StoreUpdateResponse) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&StoreUpdateResponse{`, + `Sandbox:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Sandbox), "Sandbox", "types.Sandbox", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *StoreDeleteRequest) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&StoreDeleteRequest{`, + `SandboxID:` + fmt.Sprintf("%v", this.SandboxID) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *StoreDeleteResponse) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&StoreDeleteResponse{`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *StoreListRequest) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&StoreListRequest{`, + `Filters:` + fmt.Sprintf("%v", this.Filters) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *StoreListResponse) String() string { + if this == nil { + return "nil" + } + repeatedStringForList := "[]Sandbox{" + for _, f := range this.List { + repeatedStringForList += fmt.Sprintf("%v", f) + "," + } + repeatedStringForList += "}" + s := strings.Join([]string{`&StoreListResponse{`, + `List:` + repeatedStringForList + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *StoreGetRequest) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&StoreGetRequest{`, + `SandboxID:` + fmt.Sprintf("%v", this.SandboxID) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *StoreGetResponse) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&StoreGetResponse{`, + `Sandbox:` + strings.Replace(fmt.Sprintf("%v", this.Sandbox), "Sandbox", "types.Sandbox", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *ControllerStartRequest) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ControllerStartRequest{`, + `SandboxID:` + fmt.Sprintf("%v", this.SandboxID) + `,`, + `Spec:` + strings.Replace(fmt.Sprintf("%v", this.Spec), "Any", "types1.Any", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *ControllerStartResponse) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ControllerStartResponse{`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *ControllerShutdownRequest) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ControllerShutdownRequest{`, + `SandboxID:` + fmt.Sprintf("%v", this.SandboxID) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *ControllerShutdownResponse) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ControllerShutdownResponse{`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *ControllerPauseRequest) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ControllerPauseRequest{`, + `SandboxID:` + fmt.Sprintf("%v", this.SandboxID) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *ControllerPauseResponse) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ControllerPauseResponse{`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *ControllerResumeRequest) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ControllerResumeRequest{`, + `SandboxID:` + fmt.Sprintf("%v", this.SandboxID) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *ControllerResumeResponse) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ControllerResumeResponse{`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *ControllerPingRequest) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ControllerPingRequest{`, + `SandboxID:` + fmt.Sprintf("%v", this.SandboxID) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *ControllerPingResponse) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ControllerPingResponse{`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *ControllerStatusRequest) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ControllerStatusRequest{`, + `SandboxID:` + fmt.Sprintf("%v", this.SandboxID) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *ControllerStatusResponse) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ControllerStatusResponse{`, + `Status:` + strings.Replace(fmt.Sprintf("%v", this.Status), "Any", "types1.Any", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func valueToStringSandbox(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *StoreCreateRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StoreCreateRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StoreCreateRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sandbox", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Sandbox.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StoreCreateResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StoreCreateResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StoreCreateResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sandbox", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Sandbox.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StoreUpdateRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StoreUpdateRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StoreUpdateRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sandbox", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Sandbox.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Fields", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Fields = append(m.Fields, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StoreUpdateResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StoreUpdateResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StoreUpdateResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sandbox", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Sandbox.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StoreDeleteRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StoreDeleteRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StoreDeleteRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SandboxID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SandboxID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StoreDeleteResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StoreDeleteResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StoreDeleteResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StoreListRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StoreListRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StoreListRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Filters", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Filters = append(m.Filters, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StoreListResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StoreListResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StoreListResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field List", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.List = append(m.List, types.Sandbox{}) + if err := m.List[len(m.List)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StoreGetRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StoreGetRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StoreGetRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SandboxID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SandboxID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StoreGetResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StoreGetResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StoreGetResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sandbox", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Sandbox == nil { + m.Sandbox = &types.Sandbox{} + } + if err := m.Sandbox.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ControllerStartRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ControllerStartRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ControllerStartRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SandboxID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SandboxID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Spec == nil { + m.Spec = &types1.Any{} + } + if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ControllerStartResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ControllerStartResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ControllerStartResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ControllerShutdownRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ControllerShutdownRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ControllerShutdownRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SandboxID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SandboxID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ControllerShutdownResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ControllerShutdownResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ControllerShutdownResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ControllerPauseRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ControllerPauseRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ControllerPauseRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SandboxID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SandboxID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ControllerPauseResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ControllerPauseResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ControllerPauseResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ControllerResumeRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ControllerResumeRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ControllerResumeRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SandboxID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SandboxID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ControllerResumeResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ControllerResumeResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ControllerResumeResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ControllerPingRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ControllerPingRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ControllerPingRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SandboxID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SandboxID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ControllerPingResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ControllerPingResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ControllerPingResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ControllerStatusRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ControllerStatusRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ControllerStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SandboxID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SandboxID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ControllerStatusResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ControllerStatusResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ControllerStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Status == nil { + m.Status = &types1.Any{} + } + if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipSandbox(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSandbox + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSandbox + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSandbox + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthSandbox + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupSandbox + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthSandbox + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthSandbox = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowSandbox = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupSandbox = fmt.Errorf("proto: unexpected end of group") +) diff --git a/api/services/sandbox/v1/sandbox.proto b/api/services/sandbox/v1/sandbox.proto new file mode 100644 index 000000000..be9d938ed --- /dev/null +++ b/api/services/sandbox/v1/sandbox.proto @@ -0,0 +1,132 @@ +/* + Copyright The containerd Authors. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + +syntax = "proto3"; + +// Sandbox is a v2 runtime extension that allows more complex execution environments for containers. +// This adds a notion of groups of containers that share same lifecycle and/or resources. +// A few good fits for sandbox can be: +// - A "pause" container in k8s, that acts as a parent process for child containers to hold network namespace. +// - (micro)VMs that launch a VM process and executes containers inside guest OS. +// containerd in this case remains implementation agnostic and delegates sandbox handling to runtimes. +// See proposal and discussion here: https://github.com/containerd/containerd/issues/4131 +package containerd.services.sandbox.v1; + +import weak "gogoproto/gogo.proto"; +import "google/protobuf/any.proto"; +import "github.com/containerd/containerd/api/types/sandbox.proto"; + +option go_package = "github.com/containerd/containerd/api/services/sandbox/v1;sandbox"; + +// Store provides a metadata storage interface for sandboxes. Similarly to `Containers`, +// sandbox object includes info required to start a new instance, but no runtime state. +// When running a new sandbox instance, store objects are used as base type to create from. +service Store { + rpc Create(StoreCreateRequest) returns (StoreCreateResponse); + rpc Update(StoreUpdateRequest) returns (StoreUpdateResponse); + rpc Delete(StoreDeleteRequest) returns (StoreDeleteResponse); + rpc List(StoreListRequest) returns (StoreListResponse); + rpc Get(StoreGetRequest) returns (StoreGetResponse); +} + +message StoreCreateRequest { + containerd.types.Sandbox sandbox = 1 [(gogoproto.nullable) = false]; +} + +message StoreCreateResponse { + containerd.types.Sandbox sandbox = 1 [(gogoproto.nullable) = false]; +} + +message StoreUpdateRequest { + containerd.types.Sandbox sandbox = 1 [(gogoproto.nullable) = false]; + repeated string fields = 2; +} + +message StoreUpdateResponse { + containerd.types.Sandbox sandbox = 1 [(gogoproto.nullable) = false]; +} + +message StoreDeleteRequest { + string sandbox_id = 1; +} + +message StoreDeleteResponse {} + +message StoreListRequest { + repeated string filters = 1; +} + +message StoreListResponse { + repeated containerd.types.Sandbox list = 1 [(gogoproto.nullable) = false]; +} + +message StoreGetRequest { + string sandbox_id = 1; +} + +message StoreGetResponse { + containerd.types.Sandbox sandbox = 1; +} + +// Controller is an interface to manage runtime sandbox instances. +service Controller { + rpc Start(ControllerStartRequest) returns (ControllerStartResponse); + rpc Shutdown(ControllerShutdownRequest) returns (ControllerShutdownResponse); + rpc Pause(ControllerPauseRequest) returns (ControllerPauseResponse); + rpc Resume(ControllerResumeRequest) returns (ControllerResumeResponse); + rpc Ping(ControllerPingRequest) returns (ControllerPingResponse); + rpc Status(ControllerStatusRequest) returns (ControllerStatusResponse); +} + +message ControllerStartRequest { + string sandbox_id = 1; + google.protobuf.Any spec = 4; +} + +message ControllerStartResponse { +} + +message ControllerShutdownRequest { + string sandbox_id = 1; +} + +message ControllerShutdownResponse {} + +message ControllerPauseRequest { + string sandbox_id = 1; +} + +message ControllerPauseResponse {} + +message ControllerResumeRequest { + string sandbox_id = 1; +} + +message ControllerResumeResponse {} + +message ControllerPingRequest { + string sandbox_id = 1; +} + +message ControllerPingResponse {} + +message ControllerStatusRequest { + string sandbox_id = 1; +} + +message ControllerStatusResponse { + google.protobuf.Any status = 1; +} diff --git a/api/types/sandbox.pb.go b/api/types/sandbox.pb.go new file mode 100644 index 000000000..d44a3587d --- /dev/null +++ b/api/types/sandbox.pb.go @@ -0,0 +1,1147 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: github.com/containerd/containerd/api/types/sandbox.proto + +package types + +import ( + fmt "fmt" + proto "github.com/gogo/protobuf/proto" + github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys" + github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" + types "github.com/gogo/protobuf/types" + io "io" + math "math" + math_bits "math/bits" + reflect "reflect" + strings "strings" + time "time" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf +var _ = time.Kitchen + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +// Sandbox represents a sandbox metadata object that keeps all info required by controller to +// work with a particular instance. containerd keeps this in metadata store and sends it to a controller with +// each request, so they can reflect sandbox state changes (by updating the corresponding fields). +type Sandbox struct { + // SandboxID is a unique instance identifier within namespace + SandboxID string `protobuf:"bytes,1,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` + // Runtime specifies which runtime to use for executing this container. + Runtime Sandbox_Runtime `protobuf:"bytes,2,opt,name=runtime,proto3" json:"runtime"` + // Spec is sandbox configuration (kin of OCI runtime spec, but for VM) + Spec *types.Any `protobuf:"bytes,3,opt,name=spec,proto3" json:"spec,omitempty"` + // Labels provides an area to include arbitrary data on containers. + Labels map[string]string `protobuf:"bytes,4,rep,name=labels,proto3" json:"labels" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + // CreatedAt is the time the container was first created. + CreatedAt time.Time `protobuf:"bytes,5,opt,name=created_at,json=createdAt,proto3,stdtime" json:"created_at"` + // UpdatedAt is the last time the container was mutated. + UpdatedAt time.Time `protobuf:"bytes,6,opt,name=updated_at,json=updatedAt,proto3,stdtime" json:"updated_at"` + // Extensions allow clients to provide optional blobs that can be handled by runtime. + Extensions map[string]types.Any `protobuf:"bytes,7,rep,name=extensions,proto3" json:"extensions" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Sandbox) Reset() { *m = Sandbox{} } +func (*Sandbox) ProtoMessage() {} +func (*Sandbox) Descriptor() ([]byte, []int) { + return fileDescriptor_f2257af6cf851f1c, []int{0} +} +func (m *Sandbox) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Sandbox) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Sandbox.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *Sandbox) XXX_Merge(src proto.Message) { + xxx_messageInfo_Sandbox.Merge(m, src) +} +func (m *Sandbox) XXX_Size() int { + return m.Size() +} +func (m *Sandbox) XXX_DiscardUnknown() { + xxx_messageInfo_Sandbox.DiscardUnknown(m) +} + +var xxx_messageInfo_Sandbox proto.InternalMessageInfo + +type Sandbox_Runtime struct { + // Name is the name of the runtime. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // Options specify additional runtime initialization options. + Options *types.Any `protobuf:"bytes,2,opt,name=options,proto3" json:"options,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Sandbox_Runtime) Reset() { *m = Sandbox_Runtime{} } +func (*Sandbox_Runtime) ProtoMessage() {} +func (*Sandbox_Runtime) Descriptor() ([]byte, []int) { + return fileDescriptor_f2257af6cf851f1c, []int{0, 0} +} +func (m *Sandbox_Runtime) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Sandbox_Runtime) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Sandbox_Runtime.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *Sandbox_Runtime) XXX_Merge(src proto.Message) { + xxx_messageInfo_Sandbox_Runtime.Merge(m, src) +} +func (m *Sandbox_Runtime) XXX_Size() int { + return m.Size() +} +func (m *Sandbox_Runtime) XXX_DiscardUnknown() { + xxx_messageInfo_Sandbox_Runtime.DiscardUnknown(m) +} + +var xxx_messageInfo_Sandbox_Runtime proto.InternalMessageInfo + +func init() { + proto.RegisterType((*Sandbox)(nil), "containerd.types.Sandbox") + proto.RegisterMapType((map[string]types.Any)(nil), "containerd.types.Sandbox.ExtensionsEntry") + proto.RegisterMapType((map[string]string)(nil), "containerd.types.Sandbox.LabelsEntry") + proto.RegisterType((*Sandbox_Runtime)(nil), "containerd.types.Sandbox.Runtime") +} + +func init() { + proto.RegisterFile("github.com/containerd/containerd/api/types/sandbox.proto", fileDescriptor_f2257af6cf851f1c) +} + +var fileDescriptor_f2257af6cf851f1c = []byte{ + // 454 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x53, 0x4f, 0x8b, 0xd3, 0x40, + 0x14, 0xef, 0xf4, 0x5f, 0xcc, 0x2b, 0xe2, 0x32, 0xf4, 0x10, 0x73, 0x48, 0xab, 0x20, 0x54, 0x91, + 0x89, 0xac, 0x97, 0x55, 0x4f, 0xed, 0xba, 0x87, 0x15, 0x45, 0xc8, 0x7a, 0x10, 0x2f, 0xcb, 0xa4, + 0x19, 0x63, 0xb0, 0x9d, 0x09, 0xc9, 0x44, 0x36, 0x37, 0x3f, 0x82, 0xdf, 0xc1, 0x2f, 0xd3, 0xa3, + 0x47, 0x4f, 0xab, 0x9b, 0x4f, 0x22, 0x99, 0x99, 0xd8, 0x50, 0xad, 0xb8, 0x97, 0xf0, 0x86, 0xf7, + 0xfb, 0xf7, 0xde, 0x23, 0x70, 0x14, 0x27, 0xf2, 0x43, 0x11, 0x92, 0xa5, 0x58, 0xfb, 0x4b, 0xc1, + 0x25, 0x4d, 0x38, 0xcb, 0xa2, 0x76, 0x49, 0xd3, 0xc4, 0x97, 0x65, 0xca, 0x72, 0x3f, 0xa7, 0x3c, + 0x0a, 0xc5, 0x05, 0x49, 0x33, 0x21, 0x05, 0x3e, 0xd8, 0x62, 0x88, 0xea, 0xbb, 0xe3, 0x58, 0xc4, + 0x42, 0x35, 0xfd, 0xba, 0xd2, 0x38, 0xf7, 0x76, 0x2c, 0x44, 0xbc, 0x62, 0xbe, 0x7a, 0x85, 0xc5, + 0x7b, 0x9f, 0xf2, 0xd2, 0xb4, 0x26, 0xbb, 0x2d, 0x99, 0xac, 0x59, 0x2e, 0xe9, 0x3a, 0xd5, 0x80, + 0xbb, 0x5f, 0x07, 0x60, 0x9d, 0x69, 0x57, 0xfc, 0x10, 0xc0, 0x04, 0x38, 0x4f, 0x22, 0x07, 0x4d, + 0xd1, 0xcc, 0x5e, 0xdc, 0xac, 0x2e, 0x27, 0xb6, 0x01, 0x9c, 0x3e, 0x0f, 0x6c, 0x03, 0x38, 0x8d, + 0xf0, 0x1c, 0xac, 0xac, 0xe0, 0xb5, 0x9e, 0xd3, 0x9d, 0xa2, 0xd9, 0xe8, 0xf0, 0x0e, 0xd9, 0xcd, + 0x4b, 0x0c, 0x91, 0x04, 0x1a, 0xb8, 0xe8, 0x6f, 0x2e, 0x27, 0x9d, 0xa0, 0xe1, 0xe1, 0x19, 0xf4, + 0xf3, 0x94, 0x2d, 0x9d, 0x9e, 0xe2, 0x8f, 0x89, 0x0e, 0x4b, 0x9a, 0xb0, 0x64, 0xce, 0xcb, 0x40, + 0x21, 0xf0, 0x31, 0x0c, 0x57, 0x34, 0x64, 0xab, 0xdc, 0xe9, 0x4f, 0x7b, 0xb3, 0xd1, 0xe1, 0xbd, + 0xfd, 0x5e, 0x2f, 0x15, 0xee, 0x84, 0xcb, 0xac, 0x34, 0x7e, 0x86, 0x8a, 0x8f, 0x01, 0x96, 0x19, + 0xa3, 0x92, 0x45, 0xe7, 0x54, 0x3a, 0x03, 0x65, 0xea, 0xfe, 0x61, 0xfa, 0xa6, 0xd9, 0xd0, 0xe2, + 0x46, 0xcd, 0xfe, 0xf2, 0x63, 0x82, 0x02, 0xdb, 0xf0, 0xe6, 0xb2, 0x16, 0x29, 0xd2, 0xa8, 0x11, + 0x19, 0x5e, 0x47, 0xc4, 0xf0, 0xe6, 0x12, 0xbf, 0x06, 0x60, 0x17, 0x92, 0xf1, 0x3c, 0x11, 0x3c, + 0x77, 0x2c, 0x35, 0xd2, 0xfd, 0xfd, 0x23, 0x9d, 0xfc, 0xc6, 0xb6, 0xc7, 0x6a, 0x49, 0xb8, 0xaf, + 0xc0, 0x32, 0x3b, 0xc6, 0x18, 0xfa, 0x9c, 0xae, 0x99, 0xbe, 0x5f, 0xa0, 0x6a, 0x4c, 0xc0, 0x12, + 0xa9, 0x54, 0x66, 0xdd, 0x7f, 0xec, 0xba, 0x01, 0xb9, 0x4f, 0x60, 0xd4, 0x5a, 0x23, 0x3e, 0x80, + 0xde, 0x47, 0x56, 0x1a, 0xc5, 0xba, 0xc4, 0x63, 0x18, 0x7c, 0xa2, 0xab, 0x42, 0x9f, 0xde, 0x0e, + 0xf4, 0xe3, 0x69, 0xf7, 0x08, 0xb9, 0x67, 0x70, 0x6b, 0x27, 0xee, 0x5f, 0xe8, 0x0f, 0xda, 0xf4, + 0x7d, 0x69, 0xb6, 0xa2, 0x8b, 0x17, 0x9b, 0x2b, 0xaf, 0xf3, 0xfd, 0xca, 0xeb, 0x7c, 0xae, 0x3c, + 0xb4, 0xa9, 0x3c, 0xf4, 0xad, 0xf2, 0xd0, 0xcf, 0xca, 0x43, 0xef, 0x1e, 0xfd, 0xff, 0xdf, 0xf5, + 0x4c, 0x7d, 0xdf, 0x76, 0xc2, 0xa1, 0xb2, 0x79, 0xfc, 0x2b, 0x00, 0x00, 0xff, 0xff, 0x90, 0x58, + 0x3c, 0xe1, 0x9a, 0x03, 0x00, 0x00, +} + +func (m *Sandbox) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Sandbox) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Sandbox) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Extensions) > 0 { + for k := range m.Extensions { + v := m.Extensions[k] + baseI := i + { + size, err := (&v).MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSandbox(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + i -= len(k) + copy(dAtA[i:], k) + i = encodeVarintSandbox(dAtA, i, uint64(len(k))) + i-- + dAtA[i] = 0xa + i = encodeVarintSandbox(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x3a + } + } + n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UpdatedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt):]) + if err2 != nil { + return 0, err2 + } + i -= n2 + i = encodeVarintSandbox(dAtA, i, uint64(n2)) + i-- + dAtA[i] = 0x32 + n3, err3 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CreatedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt):]) + if err3 != nil { + return 0, err3 + } + i -= n3 + i = encodeVarintSandbox(dAtA, i, uint64(n3)) + i-- + dAtA[i] = 0x2a + if len(m.Labels) > 0 { + for k := range m.Labels { + v := m.Labels[k] + baseI := i + i -= len(v) + copy(dAtA[i:], v) + i = encodeVarintSandbox(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + i -= len(k) + copy(dAtA[i:], k) + i = encodeVarintSandbox(dAtA, i, uint64(len(k))) + i-- + dAtA[i] = 0xa + i = encodeVarintSandbox(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x22 + } + } + if m.Spec != nil { + { + size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSandbox(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + { + size, err := m.Runtime.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSandbox(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + if len(m.SandboxID) > 0 { + i -= len(m.SandboxID) + copy(dAtA[i:], m.SandboxID) + i = encodeVarintSandbox(dAtA, i, uint64(len(m.SandboxID))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Sandbox_Runtime) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Sandbox_Runtime) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Sandbox_Runtime) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.Options != nil { + { + size, err := m.Options.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSandbox(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintSandbox(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintSandbox(dAtA []byte, offset int, v uint64) int { + offset -= sovSandbox(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *Sandbox) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.SandboxID) + if l > 0 { + n += 1 + l + sovSandbox(uint64(l)) + } + l = m.Runtime.Size() + n += 1 + l + sovSandbox(uint64(l)) + if m.Spec != nil { + l = m.Spec.Size() + n += 1 + l + sovSandbox(uint64(l)) + } + if len(m.Labels) > 0 { + for k, v := range m.Labels { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovSandbox(uint64(len(k))) + 1 + len(v) + sovSandbox(uint64(len(v))) + n += mapEntrySize + 1 + sovSandbox(uint64(mapEntrySize)) + } + } + l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt) + n += 1 + l + sovSandbox(uint64(l)) + l = github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt) + n += 1 + l + sovSandbox(uint64(l)) + if len(m.Extensions) > 0 { + for k, v := range m.Extensions { + _ = k + _ = v + l = v.Size() + mapEntrySize := 1 + len(k) + sovSandbox(uint64(len(k))) + 1 + l + sovSandbox(uint64(l)) + n += mapEntrySize + 1 + sovSandbox(uint64(mapEntrySize)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Sandbox_Runtime) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovSandbox(uint64(l)) + } + if m.Options != nil { + l = m.Options.Size() + n += 1 + l + sovSandbox(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovSandbox(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozSandbox(x uint64) (n int) { + return sovSandbox(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Sandbox) String() string { + if this == nil { + return "nil" + } + keysForLabels := make([]string, 0, len(this.Labels)) + for k, _ := range this.Labels { + keysForLabels = append(keysForLabels, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) + mapStringForLabels := "map[string]string{" + for _, k := range keysForLabels { + mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) + } + mapStringForLabels += "}" + keysForExtensions := make([]string, 0, len(this.Extensions)) + for k, _ := range this.Extensions { + keysForExtensions = append(keysForExtensions, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForExtensions) + mapStringForExtensions := "map[string]types.Any{" + for _, k := range keysForExtensions { + mapStringForExtensions += fmt.Sprintf("%v: %v,", k, this.Extensions[k]) + } + mapStringForExtensions += "}" + s := strings.Join([]string{`&Sandbox{`, + `SandboxID:` + fmt.Sprintf("%v", this.SandboxID) + `,`, + `Runtime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Runtime), "Sandbox_Runtime", "Sandbox_Runtime", 1), `&`, ``, 1) + `,`, + `Spec:` + strings.Replace(fmt.Sprintf("%v", this.Spec), "Any", "types.Any", 1) + `,`, + `Labels:` + mapStringForLabels + `,`, + `CreatedAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.CreatedAt), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`, + `UpdatedAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.UpdatedAt), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`, + `Extensions:` + mapStringForExtensions + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Sandbox_Runtime) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Sandbox_Runtime{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `Options:` + strings.Replace(fmt.Sprintf("%v", this.Options), "Any", "types.Any", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func valueToStringSandbox(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *Sandbox) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Sandbox: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Sandbox: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SandboxID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SandboxID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Runtime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Runtime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Spec == nil { + m.Spec = &types.Any{} + } + if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Labels == nil { + m.Labels = make(map[string]string) + } + var mapkey string + var mapvalue string + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthSandbox + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLengthSandbox + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapvalue |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return ErrInvalidLengthSandbox + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue < 0 { + return ErrInvalidLengthSandbox + } + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + } else { + iNdEx = entryPreIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.Labels[mapkey] = mapvalue + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CreatedAt, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAt", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.UpdatedAt, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Extensions", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Extensions == nil { + m.Extensions = make(map[string]types.Any) + } + var mapkey string + mapvalue := &types.Any{} + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthSandbox + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLengthSandbox + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapmsglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthSandbox + } + postmsgIndex := iNdEx + mapmsglen + if postmsgIndex < 0 { + return ErrInvalidLengthSandbox + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue = &types.Any{} + if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + } else { + iNdEx = entryPreIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.Extensions[mapkey] = *mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Sandbox_Runtime) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Runtime: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Runtime: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Options == nil { + m.Options = &types.Any{} + } + if err := m.Options.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipSandbox(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSandbox + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSandbox + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSandbox + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthSandbox + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupSandbox + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthSandbox + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthSandbox = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowSandbox = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupSandbox = fmt.Errorf("proto: unexpected end of group") +) diff --git a/api/types/sandbox.proto b/api/types/sandbox.proto new file mode 100644 index 000000000..b40e84bf4 --- /dev/null +++ b/api/types/sandbox.proto @@ -0,0 +1,51 @@ +/* + Copyright The containerd Authors. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + +syntax = "proto3"; + +package containerd.types; + +import weak "gogoproto/gogo.proto"; +import "google/protobuf/any.proto"; +import "google/protobuf/timestamp.proto"; + +option go_package = "github.com/containerd/containerd/api/types;types"; + +// Sandbox represents a sandbox metadata object that keeps all info required by controller to +// work with a particular instance. containerd keeps this in metadata store and sends it to a controller with +// each request, so they can reflect sandbox state changes (by updating the corresponding fields). +message Sandbox { + // SandboxID is a unique instance identifier within namespace + string sandbox_id = 1; + message Runtime { + // Name is the name of the runtime. + string name = 1; + // Options specify additional runtime initialization options. + google.protobuf.Any options = 2; + } + // Runtime specifies which runtime to use for executing this container. + Runtime runtime = 2 [(gogoproto.nullable) = false]; + // Spec is sandbox configuration (kin of OCI runtime spec, but for VM) + google.protobuf.Any spec = 3; + // Labels provides an area to include arbitrary data on containers. + map labels = 4 [(gogoproto.nullable) = false]; + // CreatedAt is the time the container was first created. + google.protobuf.Timestamp created_at = 5 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; + // UpdatedAt is the last time the container was mutated. + google.protobuf.Timestamp updated_at = 6 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; + // Extensions allow clients to provide optional blobs that can be handled by runtime. + map extensions = 7 [(gogoproto.nullable) = false]; +} diff --git a/runtime/v2/task/sandbox.pb.go b/runtime/v2/task/sandbox.pb.go new file mode 100644 index 000000000..23cb6402c --- /dev/null +++ b/runtime/v2/task/sandbox.pb.go @@ -0,0 +1,2972 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: github.com/containerd/containerd/runtime/v2/task/sandbox.proto + +package task + +import ( + context "context" + fmt "fmt" + github_com_containerd_ttrpc "github.com/containerd/ttrpc" + proto "github.com/gogo/protobuf/proto" + github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys" + types "github.com/gogo/protobuf/types" + io "io" + math "math" + math_bits "math/bits" + reflect "reflect" + strings "strings" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type StartSandboxRequest struct { + SandboxID string `protobuf:"bytes,1,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` + BundlePath string `protobuf:"bytes,2,opt,name=bundle_path,json=bundlePath,proto3" json:"bundle_path,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *StartSandboxRequest) Reset() { *m = StartSandboxRequest{} } +func (*StartSandboxRequest) ProtoMessage() {} +func (*StartSandboxRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_1a2e6d1f55947a07, []int{0} +} +func (m *StartSandboxRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StartSandboxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StartSandboxRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *StartSandboxRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_StartSandboxRequest.Merge(m, src) +} +func (m *StartSandboxRequest) XXX_Size() int { + return m.Size() +} +func (m *StartSandboxRequest) XXX_DiscardUnknown() { + xxx_messageInfo_StartSandboxRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_StartSandboxRequest proto.InternalMessageInfo + +type StartSandboxResponse struct { + Pid string `protobuf:"bytes,1,opt,name=pid,proto3" json:"pid,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *StartSandboxResponse) Reset() { *m = StartSandboxResponse{} } +func (*StartSandboxResponse) ProtoMessage() {} +func (*StartSandboxResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_1a2e6d1f55947a07, []int{1} +} +func (m *StartSandboxResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StartSandboxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StartSandboxResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *StartSandboxResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_StartSandboxResponse.Merge(m, src) +} +func (m *StartSandboxResponse) XXX_Size() int { + return m.Size() +} +func (m *StartSandboxResponse) XXX_DiscardUnknown() { + xxx_messageInfo_StartSandboxResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_StartSandboxResponse proto.InternalMessageInfo + +type StopSandboxRequest struct { + SandboxID string `protobuf:"bytes,1,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` + TimeoutSecs uint32 `protobuf:"varint,2,opt,name=timeout_secs,json=timeoutSecs,proto3" json:"timeout_secs,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *StopSandboxRequest) Reset() { *m = StopSandboxRequest{} } +func (*StopSandboxRequest) ProtoMessage() {} +func (*StopSandboxRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_1a2e6d1f55947a07, []int{2} +} +func (m *StopSandboxRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StopSandboxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StopSandboxRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *StopSandboxRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_StopSandboxRequest.Merge(m, src) +} +func (m *StopSandboxRequest) XXX_Size() int { + return m.Size() +} +func (m *StopSandboxRequest) XXX_DiscardUnknown() { + xxx_messageInfo_StopSandboxRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_StopSandboxRequest proto.InternalMessageInfo + +type StopSandboxResponse struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *StopSandboxResponse) Reset() { *m = StopSandboxResponse{} } +func (*StopSandboxResponse) ProtoMessage() {} +func (*StopSandboxResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_1a2e6d1f55947a07, []int{3} +} +func (m *StopSandboxResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StopSandboxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StopSandboxResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *StopSandboxResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_StopSandboxResponse.Merge(m, src) +} +func (m *StopSandboxResponse) XXX_Size() int { + return m.Size() +} +func (m *StopSandboxResponse) XXX_DiscardUnknown() { + xxx_messageInfo_StopSandboxResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_StopSandboxResponse proto.InternalMessageInfo + +type UpdateSandboxRequest struct { + SandboxID string `protobuf:"bytes,1,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` + Resources *types.Any `protobuf:"bytes,2,opt,name=resources,proto3" json:"resources,omitempty"` + Annotations map[string]string `protobuf:"bytes,3,rep,name=annotations,proto3" json:"annotations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *UpdateSandboxRequest) Reset() { *m = UpdateSandboxRequest{} } +func (*UpdateSandboxRequest) ProtoMessage() {} +func (*UpdateSandboxRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_1a2e6d1f55947a07, []int{4} +} +func (m *UpdateSandboxRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *UpdateSandboxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_UpdateSandboxRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *UpdateSandboxRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_UpdateSandboxRequest.Merge(m, src) +} +func (m *UpdateSandboxRequest) XXX_Size() int { + return m.Size() +} +func (m *UpdateSandboxRequest) XXX_DiscardUnknown() { + xxx_messageInfo_UpdateSandboxRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_UpdateSandboxRequest proto.InternalMessageInfo + +type UpdateSandboxResponse struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *UpdateSandboxResponse) Reset() { *m = UpdateSandboxResponse{} } +func (*UpdateSandboxResponse) ProtoMessage() {} +func (*UpdateSandboxResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_1a2e6d1f55947a07, []int{5} +} +func (m *UpdateSandboxResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *UpdateSandboxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_UpdateSandboxResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *UpdateSandboxResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_UpdateSandboxResponse.Merge(m, src) +} +func (m *UpdateSandboxResponse) XXX_Size() int { + return m.Size() +} +func (m *UpdateSandboxResponse) XXX_DiscardUnknown() { + xxx_messageInfo_UpdateSandboxResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_UpdateSandboxResponse proto.InternalMessageInfo + +type SandboxStatusRequest struct { + SandboxID string `protobuf:"bytes,1,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SandboxStatusRequest) Reset() { *m = SandboxStatusRequest{} } +func (*SandboxStatusRequest) ProtoMessage() {} +func (*SandboxStatusRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_1a2e6d1f55947a07, []int{6} +} +func (m *SandboxStatusRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SandboxStatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SandboxStatusRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *SandboxStatusRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SandboxStatusRequest.Merge(m, src) +} +func (m *SandboxStatusRequest) XXX_Size() int { + return m.Size() +} +func (m *SandboxStatusRequest) XXX_DiscardUnknown() { + xxx_messageInfo_SandboxStatusRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_SandboxStatusRequest proto.InternalMessageInfo + +type PauseSandboxRequest struct { + SandboxID string `protobuf:"bytes,1,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PauseSandboxRequest) Reset() { *m = PauseSandboxRequest{} } +func (*PauseSandboxRequest) ProtoMessage() {} +func (*PauseSandboxRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_1a2e6d1f55947a07, []int{7} +} +func (m *PauseSandboxRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PauseSandboxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PauseSandboxRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *PauseSandboxRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_PauseSandboxRequest.Merge(m, src) +} +func (m *PauseSandboxRequest) XXX_Size() int { + return m.Size() +} +func (m *PauseSandboxRequest) XXX_DiscardUnknown() { + xxx_messageInfo_PauseSandboxRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_PauseSandboxRequest proto.InternalMessageInfo + +type PauseSandboxResponse struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PauseSandboxResponse) Reset() { *m = PauseSandboxResponse{} } +func (*PauseSandboxResponse) ProtoMessage() {} +func (*PauseSandboxResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_1a2e6d1f55947a07, []int{8} +} +func (m *PauseSandboxResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PauseSandboxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PauseSandboxResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *PauseSandboxResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_PauseSandboxResponse.Merge(m, src) +} +func (m *PauseSandboxResponse) XXX_Size() int { + return m.Size() +} +func (m *PauseSandboxResponse) XXX_DiscardUnknown() { + xxx_messageInfo_PauseSandboxResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_PauseSandboxResponse proto.InternalMessageInfo + +type ResumeSandboxRequest struct { + SandboxID string `protobuf:"bytes,1,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ResumeSandboxRequest) Reset() { *m = ResumeSandboxRequest{} } +func (*ResumeSandboxRequest) ProtoMessage() {} +func (*ResumeSandboxRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_1a2e6d1f55947a07, []int{9} +} +func (m *ResumeSandboxRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ResumeSandboxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ResumeSandboxRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ResumeSandboxRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ResumeSandboxRequest.Merge(m, src) +} +func (m *ResumeSandboxRequest) XXX_Size() int { + return m.Size() +} +func (m *ResumeSandboxRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ResumeSandboxRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ResumeSandboxRequest proto.InternalMessageInfo + +type ResumeSandboxResponse struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ResumeSandboxResponse) Reset() { *m = ResumeSandboxResponse{} } +func (*ResumeSandboxResponse) ProtoMessage() {} +func (*ResumeSandboxResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_1a2e6d1f55947a07, []int{10} +} +func (m *ResumeSandboxResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ResumeSandboxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ResumeSandboxResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ResumeSandboxResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ResumeSandboxResponse.Merge(m, src) +} +func (m *ResumeSandboxResponse) XXX_Size() int { + return m.Size() +} +func (m *ResumeSandboxResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ResumeSandboxResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ResumeSandboxResponse proto.InternalMessageInfo + +type SandboxStatusResponse struct { + Status *types.Any `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SandboxStatusResponse) Reset() { *m = SandboxStatusResponse{} } +func (*SandboxStatusResponse) ProtoMessage() {} +func (*SandboxStatusResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_1a2e6d1f55947a07, []int{11} +} +func (m *SandboxStatusResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SandboxStatusResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SandboxStatusResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *SandboxStatusResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_SandboxStatusResponse.Merge(m, src) +} +func (m *SandboxStatusResponse) XXX_Size() int { + return m.Size() +} +func (m *SandboxStatusResponse) XXX_DiscardUnknown() { + xxx_messageInfo_SandboxStatusResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_SandboxStatusResponse proto.InternalMessageInfo + +type PingRequest struct { + SandboxID string `protobuf:"bytes,1,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PingRequest) Reset() { *m = PingRequest{} } +func (*PingRequest) ProtoMessage() {} +func (*PingRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_1a2e6d1f55947a07, []int{12} +} +func (m *PingRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PingRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *PingRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_PingRequest.Merge(m, src) +} +func (m *PingRequest) XXX_Size() int { + return m.Size() +} +func (m *PingRequest) XXX_DiscardUnknown() { + xxx_messageInfo_PingRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_PingRequest proto.InternalMessageInfo + +type PingResponse struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PingResponse) Reset() { *m = PingResponse{} } +func (*PingResponse) ProtoMessage() {} +func (*PingResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_1a2e6d1f55947a07, []int{13} +} +func (m *PingResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PingResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *PingResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_PingResponse.Merge(m, src) +} +func (m *PingResponse) XXX_Size() int { + return m.Size() +} +func (m *PingResponse) XXX_DiscardUnknown() { + xxx_messageInfo_PingResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_PingResponse proto.InternalMessageInfo + +func init() { + proto.RegisterType((*StartSandboxRequest)(nil), "containerd.task.v2.StartSandboxRequest") + proto.RegisterType((*StartSandboxResponse)(nil), "containerd.task.v2.StartSandboxResponse") + proto.RegisterType((*StopSandboxRequest)(nil), "containerd.task.v2.StopSandboxRequest") + proto.RegisterType((*StopSandboxResponse)(nil), "containerd.task.v2.StopSandboxResponse") + proto.RegisterType((*UpdateSandboxRequest)(nil), "containerd.task.v2.UpdateSandboxRequest") + proto.RegisterMapType((map[string]string)(nil), "containerd.task.v2.UpdateSandboxRequest.AnnotationsEntry") + proto.RegisterType((*UpdateSandboxResponse)(nil), "containerd.task.v2.UpdateSandboxResponse") + proto.RegisterType((*SandboxStatusRequest)(nil), "containerd.task.v2.SandboxStatusRequest") + proto.RegisterType((*PauseSandboxRequest)(nil), "containerd.task.v2.PauseSandboxRequest") + proto.RegisterType((*PauseSandboxResponse)(nil), "containerd.task.v2.PauseSandboxResponse") + proto.RegisterType((*ResumeSandboxRequest)(nil), "containerd.task.v2.ResumeSandboxRequest") + proto.RegisterType((*ResumeSandboxResponse)(nil), "containerd.task.v2.ResumeSandboxResponse") + proto.RegisterType((*SandboxStatusResponse)(nil), "containerd.task.v2.SandboxStatusResponse") + proto.RegisterType((*PingRequest)(nil), "containerd.task.v2.PingRequest") + proto.RegisterType((*PingResponse)(nil), "containerd.task.v2.PingResponse") +} + +func init() { + proto.RegisterFile("github.com/containerd/containerd/runtime/v2/task/sandbox.proto", fileDescriptor_1a2e6d1f55947a07) +} + +var fileDescriptor_1a2e6d1f55947a07 = []byte{ + // 588 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x54, 0x4d, 0x6f, 0xda, 0x40, + 0x10, 0x8d, 0x41, 0x49, 0xc5, 0x18, 0xaa, 0x68, 0x63, 0x1a, 0xea, 0x83, 0xa1, 0x3e, 0x34, 0x54, + 0x8a, 0x6c, 0xc9, 0xbd, 0xf4, 0x43, 0x8a, 0x94, 0x34, 0x39, 0xe4, 0x86, 0x8c, 0x7a, 0xaa, 0x54, + 0xb4, 0xe0, 0x2d, 0x58, 0xc0, 0xae, 0xeb, 0x5d, 0xa3, 0x72, 0xeb, 0x9f, 0xe8, 0x2f, 0xe9, 0x9f, + 0xc8, 0xb1, 0xc7, 0x9e, 0xaa, 0x86, 0x5f, 0x52, 0x99, 0x5d, 0x84, 0xa1, 0x1b, 0x25, 0x0a, 0xb7, + 0x65, 0x79, 0xfb, 0xde, 0xcc, 0x9b, 0x37, 0x86, 0xb3, 0x61, 0x2c, 0x46, 0x59, 0xdf, 0x1b, 0xb0, + 0xa9, 0x3f, 0x60, 0x54, 0xe0, 0x98, 0x92, 0x34, 0x2a, 0x1e, 0xd3, 0x8c, 0x8a, 0x78, 0x4a, 0xfc, + 0x59, 0xe0, 0x0b, 0xcc, 0xc7, 0x3e, 0xc7, 0x34, 0xea, 0xb3, 0x6f, 0x5e, 0x92, 0x32, 0xc1, 0x10, + 0x5a, 0x23, 0xbd, 0xfc, 0x6f, 0x6f, 0x16, 0xd8, 0xcf, 0x87, 0x8c, 0x0d, 0x27, 0xc4, 0x5f, 0x22, + 0xfa, 0xd9, 0x17, 0x1f, 0xd3, 0xb9, 0x84, 0xbb, 0x11, 0x1c, 0x75, 0x05, 0x4e, 0x45, 0x57, 0x92, + 0x84, 0xe4, 0x6b, 0x46, 0xb8, 0x40, 0xa7, 0x00, 0x8a, 0xb6, 0x17, 0x47, 0x0d, 0xa3, 0x65, 0xb4, + 0x2b, 0x17, 0xb5, 0xc5, 0x9f, 0x66, 0x45, 0xe1, 0xae, 0x2f, 0xc3, 0x8a, 0x02, 0x5c, 0x47, 0xa8, + 0x09, 0x66, 0x3f, 0xa3, 0xd1, 0x84, 0xf4, 0x12, 0x2c, 0x46, 0x8d, 0x52, 0x0e, 0x0f, 0x41, 0x5e, + 0x75, 0xb0, 0x18, 0xb9, 0x6d, 0xb0, 0x36, 0x55, 0x78, 0xc2, 0x28, 0x27, 0xe8, 0x10, 0xca, 0xc9, + 0x8a, 0x3f, 0xcc, 0x8f, 0x2e, 0x01, 0xd4, 0x15, 0x2c, 0xd9, 0xa9, 0x9c, 0x17, 0x50, 0xcd, 0x0d, + 0x62, 0x99, 0xe8, 0x71, 0x32, 0xe0, 0xcb, 0x7a, 0x6a, 0xa1, 0xa9, 0xee, 0xba, 0x64, 0xc0, 0xdd, + 0x7a, 0xde, 0x76, 0x41, 0x46, 0xd6, 0xe3, 0xfe, 0x28, 0x81, 0xf5, 0x31, 0x89, 0xb0, 0x20, 0x3b, + 0x15, 0x10, 0x40, 0x25, 0x25, 0x9c, 0x65, 0xe9, 0x80, 0x48, 0x75, 0x33, 0xb0, 0x3c, 0x39, 0x03, + 0x6f, 0x35, 0x03, 0xef, 0x9c, 0xce, 0xc3, 0x35, 0x0c, 0x7d, 0x02, 0x13, 0x53, 0xca, 0x04, 0x16, + 0x31, 0xa3, 0xbc, 0x51, 0x6e, 0x95, 0xdb, 0x66, 0xf0, 0xd6, 0xfb, 0x7f, 0x9a, 0x9e, 0xae, 0x40, + 0xef, 0x7c, 0xfd, 0xf6, 0x8a, 0x8a, 0x74, 0x1e, 0x16, 0xd9, 0xec, 0x33, 0x38, 0xdc, 0x06, 0xe4, + 0xde, 0x8f, 0xc9, 0x7c, 0xe5, 0xfd, 0x98, 0xcc, 0x91, 0x05, 0xfb, 0x33, 0x3c, 0xc9, 0x88, 0x1a, + 0xa0, 0xfc, 0xf1, 0xae, 0xf4, 0xc6, 0x70, 0x8f, 0xa1, 0xbe, 0xa5, 0xaa, 0x0c, 0xbb, 0x04, 0x4b, + 0x5d, 0x75, 0x05, 0x16, 0x19, 0x7f, 0x94, 0x5f, 0xee, 0x07, 0x38, 0xea, 0xe0, 0x8c, 0xef, 0x64, + 0xba, 0xfb, 0x0c, 0xac, 0x4d, 0x92, 0x75, 0x89, 0x21, 0xe1, 0xd9, 0x74, 0x37, 0xf6, 0x63, 0xa8, + 0x6f, 0xb1, 0x28, 0xfa, 0x2b, 0xa8, 0x6f, 0x39, 0xa0, 0xb2, 0x7d, 0x0a, 0x07, 0x7c, 0x79, 0xb3, + 0xe4, 0xbe, 0x2b, 0x01, 0x0a, 0xe3, 0xbe, 0x07, 0xb3, 0x13, 0xd3, 0xe1, 0xe3, 0x8a, 0x7b, 0x0a, + 0x55, 0xf9, 0x58, 0x4a, 0x07, 0x3f, 0xf7, 0xe1, 0x89, 0x02, 0x22, 0x0c, 0xd5, 0xe2, 0xea, 0xa1, + 0x13, 0x5d, 0xa4, 0x34, 0x9f, 0x00, 0xbb, 0x7d, 0x3f, 0x50, 0x75, 0xfa, 0x19, 0xcc, 0xc2, 0x32, + 0xa1, 0x97, 0xfa, 0x87, 0xdb, 0x4b, 0x6d, 0x9f, 0xdc, 0x8b, 0x53, 0xfc, 0x11, 0xd4, 0x36, 0xd2, + 0x87, 0xda, 0x0f, 0x5d, 0x0b, 0xfb, 0xd5, 0x03, 0x90, 0x4a, 0x05, 0x43, 0xb5, 0x98, 0x1f, 0xbd, + 0x51, 0x9a, 0x98, 0xea, 0x8d, 0xd2, 0x45, 0x31, 0x6f, 0x64, 0x23, 0x44, 0xfa, 0x46, 0x74, 0x69, + 0xd5, 0x37, 0xa2, 0x4d, 0x64, 0xae, 0xb2, 0x91, 0x48, 0xbd, 0x8a, 0x6e, 0x6d, 0xf5, 0x2a, 0xfa, + 0x78, 0x77, 0x64, 0x60, 0x57, 0x9d, 0x34, 0xb5, 0x26, 0xac, 0x13, 0x6d, 0xb7, 0xee, 0x06, 0x48, + 0xc6, 0x8b, 0xc6, 0xcd, 0xad, 0xb3, 0xf7, 0xfb, 0xd6, 0xd9, 0xfb, 0xbe, 0x70, 0x8c, 0x9b, 0x85, + 0x63, 0xfc, 0x5a, 0x38, 0xc6, 0xdf, 0x85, 0x63, 0xf4, 0x0f, 0x96, 0x2b, 0xf3, 0xfa, 0x5f, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xb3, 0x37, 0xc5, 0x44, 0x1c, 0x07, 0x00, 0x00, +} + +func (m *StartSandboxRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StartSandboxRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StartSandboxRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.BundlePath) > 0 { + i -= len(m.BundlePath) + copy(dAtA[i:], m.BundlePath) + i = encodeVarintSandbox(dAtA, i, uint64(len(m.BundlePath))) + i-- + dAtA[i] = 0x12 + } + if len(m.SandboxID) > 0 { + i -= len(m.SandboxID) + copy(dAtA[i:], m.SandboxID) + i = encodeVarintSandbox(dAtA, i, uint64(len(m.SandboxID))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *StartSandboxResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StartSandboxResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StartSandboxResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Pid) > 0 { + i -= len(m.Pid) + copy(dAtA[i:], m.Pid) + i = encodeVarintSandbox(dAtA, i, uint64(len(m.Pid))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *StopSandboxRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StopSandboxRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StopSandboxRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.TimeoutSecs != 0 { + i = encodeVarintSandbox(dAtA, i, uint64(m.TimeoutSecs)) + i-- + dAtA[i] = 0x10 + } + if len(m.SandboxID) > 0 { + i -= len(m.SandboxID) + copy(dAtA[i:], m.SandboxID) + i = encodeVarintSandbox(dAtA, i, uint64(len(m.SandboxID))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *StopSandboxResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StopSandboxResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StopSandboxResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + return len(dAtA) - i, nil +} + +func (m *UpdateSandboxRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *UpdateSandboxRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *UpdateSandboxRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Annotations) > 0 { + for k := range m.Annotations { + v := m.Annotations[k] + baseI := i + i -= len(v) + copy(dAtA[i:], v) + i = encodeVarintSandbox(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + i -= len(k) + copy(dAtA[i:], k) + i = encodeVarintSandbox(dAtA, i, uint64(len(k))) + i-- + dAtA[i] = 0xa + i = encodeVarintSandbox(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x1a + } + } + if m.Resources != nil { + { + size, err := m.Resources.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSandbox(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.SandboxID) > 0 { + i -= len(m.SandboxID) + copy(dAtA[i:], m.SandboxID) + i = encodeVarintSandbox(dAtA, i, uint64(len(m.SandboxID))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *UpdateSandboxResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *UpdateSandboxResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *UpdateSandboxResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + return len(dAtA) - i, nil +} + +func (m *SandboxStatusRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SandboxStatusRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SandboxStatusRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.SandboxID) > 0 { + i -= len(m.SandboxID) + copy(dAtA[i:], m.SandboxID) + i = encodeVarintSandbox(dAtA, i, uint64(len(m.SandboxID))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *PauseSandboxRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PauseSandboxRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PauseSandboxRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.SandboxID) > 0 { + i -= len(m.SandboxID) + copy(dAtA[i:], m.SandboxID) + i = encodeVarintSandbox(dAtA, i, uint64(len(m.SandboxID))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *PauseSandboxResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PauseSandboxResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PauseSandboxResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + return len(dAtA) - i, nil +} + +func (m *ResumeSandboxRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ResumeSandboxRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ResumeSandboxRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.SandboxID) > 0 { + i -= len(m.SandboxID) + copy(dAtA[i:], m.SandboxID) + i = encodeVarintSandbox(dAtA, i, uint64(len(m.SandboxID))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ResumeSandboxResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ResumeSandboxResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ResumeSandboxResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + return len(dAtA) - i, nil +} + +func (m *SandboxStatusResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SandboxStatusResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SandboxStatusResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.Status != nil { + { + size, err := m.Status.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSandbox(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *PingRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PingRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PingRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.SandboxID) > 0 { + i -= len(m.SandboxID) + copy(dAtA[i:], m.SandboxID) + i = encodeVarintSandbox(dAtA, i, uint64(len(m.SandboxID))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *PingResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PingResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PingResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + return len(dAtA) - i, nil +} + +func encodeVarintSandbox(dAtA []byte, offset int, v uint64) int { + offset -= sovSandbox(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *StartSandboxRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.SandboxID) + if l > 0 { + n += 1 + l + sovSandbox(uint64(l)) + } + l = len(m.BundlePath) + if l > 0 { + n += 1 + l + sovSandbox(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *StartSandboxResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Pid) + if l > 0 { + n += 1 + l + sovSandbox(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *StopSandboxRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.SandboxID) + if l > 0 { + n += 1 + l + sovSandbox(uint64(l)) + } + if m.TimeoutSecs != 0 { + n += 1 + sovSandbox(uint64(m.TimeoutSecs)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *StopSandboxResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *UpdateSandboxRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.SandboxID) + if l > 0 { + n += 1 + l + sovSandbox(uint64(l)) + } + if m.Resources != nil { + l = m.Resources.Size() + n += 1 + l + sovSandbox(uint64(l)) + } + if len(m.Annotations) > 0 { + for k, v := range m.Annotations { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovSandbox(uint64(len(k))) + 1 + len(v) + sovSandbox(uint64(len(v))) + n += mapEntrySize + 1 + sovSandbox(uint64(mapEntrySize)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *UpdateSandboxResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *SandboxStatusRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.SandboxID) + if l > 0 { + n += 1 + l + sovSandbox(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *PauseSandboxRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.SandboxID) + if l > 0 { + n += 1 + l + sovSandbox(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *PauseSandboxResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ResumeSandboxRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.SandboxID) + if l > 0 { + n += 1 + l + sovSandbox(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ResumeSandboxResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *SandboxStatusResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Status != nil { + l = m.Status.Size() + n += 1 + l + sovSandbox(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *PingRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.SandboxID) + if l > 0 { + n += 1 + l + sovSandbox(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *PingResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovSandbox(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozSandbox(x uint64) (n int) { + return sovSandbox(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *StartSandboxRequest) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&StartSandboxRequest{`, + `SandboxID:` + fmt.Sprintf("%v", this.SandboxID) + `,`, + `BundlePath:` + fmt.Sprintf("%v", this.BundlePath) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *StartSandboxResponse) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&StartSandboxResponse{`, + `Pid:` + fmt.Sprintf("%v", this.Pid) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *StopSandboxRequest) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&StopSandboxRequest{`, + `SandboxID:` + fmt.Sprintf("%v", this.SandboxID) + `,`, + `TimeoutSecs:` + fmt.Sprintf("%v", this.TimeoutSecs) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *StopSandboxResponse) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&StopSandboxResponse{`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *UpdateSandboxRequest) String() string { + if this == nil { + return "nil" + } + keysForAnnotations := make([]string, 0, len(this.Annotations)) + for k, _ := range this.Annotations { + keysForAnnotations = append(keysForAnnotations, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations) + mapStringForAnnotations := "map[string]string{" + for _, k := range keysForAnnotations { + mapStringForAnnotations += fmt.Sprintf("%v: %v,", k, this.Annotations[k]) + } + mapStringForAnnotations += "}" + s := strings.Join([]string{`&UpdateSandboxRequest{`, + `SandboxID:` + fmt.Sprintf("%v", this.SandboxID) + `,`, + `Resources:` + strings.Replace(fmt.Sprintf("%v", this.Resources), "Any", "types.Any", 1) + `,`, + `Annotations:` + mapStringForAnnotations + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *UpdateSandboxResponse) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UpdateSandboxResponse{`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *SandboxStatusRequest) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SandboxStatusRequest{`, + `SandboxID:` + fmt.Sprintf("%v", this.SandboxID) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *PauseSandboxRequest) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&PauseSandboxRequest{`, + `SandboxID:` + fmt.Sprintf("%v", this.SandboxID) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *PauseSandboxResponse) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&PauseSandboxResponse{`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *ResumeSandboxRequest) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ResumeSandboxRequest{`, + `SandboxID:` + fmt.Sprintf("%v", this.SandboxID) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *ResumeSandboxResponse) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ResumeSandboxResponse{`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *SandboxStatusResponse) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SandboxStatusResponse{`, + `Status:` + strings.Replace(fmt.Sprintf("%v", this.Status), "Any", "types.Any", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *PingRequest) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&PingRequest{`, + `SandboxID:` + fmt.Sprintf("%v", this.SandboxID) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *PingResponse) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&PingResponse{`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func valueToStringSandbox(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} + +type SandboxService interface { + StartSandbox(ctx context.Context, req *StartSandboxRequest) (*StartSandboxResponse, error) + StopSandbox(ctx context.Context, req *StopSandboxRequest) (*StopSandboxResponse, error) + UpdateSandbox(ctx context.Context, req *UpdateSandboxRequest) (*UpdateSandboxResponse, error) + PauseSandbox(ctx context.Context, req *PauseSandboxRequest) (*PauseSandboxResponse, error) + ResumeSandbox(ctx context.Context, req *ResumeSandboxRequest) (*ResumeSandboxResponse, error) + SandboxStatus(ctx context.Context, req *SandboxStatusRequest) (*SandboxStatusResponse, error) + PingSandbox(ctx context.Context, req *PingRequest) (*PingResponse, error) +} + +func RegisterSandboxService(srv *github_com_containerd_ttrpc.Server, svc SandboxService) { + srv.Register("containerd.task.v2.Sandbox", map[string]github_com_containerd_ttrpc.Method{ + "StartSandbox": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) { + var req StartSandboxRequest + if err := unmarshal(&req); err != nil { + return nil, err + } + return svc.StartSandbox(ctx, &req) + }, + "StopSandbox": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) { + var req StopSandboxRequest + if err := unmarshal(&req); err != nil { + return nil, err + } + return svc.StopSandbox(ctx, &req) + }, + "UpdateSandbox": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) { + var req UpdateSandboxRequest + if err := unmarshal(&req); err != nil { + return nil, err + } + return svc.UpdateSandbox(ctx, &req) + }, + "PauseSandbox": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) { + var req PauseSandboxRequest + if err := unmarshal(&req); err != nil { + return nil, err + } + return svc.PauseSandbox(ctx, &req) + }, + "ResumeSandbox": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) { + var req ResumeSandboxRequest + if err := unmarshal(&req); err != nil { + return nil, err + } + return svc.ResumeSandbox(ctx, &req) + }, + "SandboxStatus": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) { + var req SandboxStatusRequest + if err := unmarshal(&req); err != nil { + return nil, err + } + return svc.SandboxStatus(ctx, &req) + }, + "PingSandbox": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) { + var req PingRequest + if err := unmarshal(&req); err != nil { + return nil, err + } + return svc.PingSandbox(ctx, &req) + }, + }) +} + +type sandboxClient struct { + client *github_com_containerd_ttrpc.Client +} + +func NewSandboxClient(client *github_com_containerd_ttrpc.Client) SandboxService { + return &sandboxClient{ + client: client, + } +} + +func (c *sandboxClient) StartSandbox(ctx context.Context, req *StartSandboxRequest) (*StartSandboxResponse, error) { + var resp StartSandboxResponse + if err := c.client.Call(ctx, "containerd.task.v2.Sandbox", "StartSandbox", req, &resp); err != nil { + return nil, err + } + return &resp, nil +} + +func (c *sandboxClient) StopSandbox(ctx context.Context, req *StopSandboxRequest) (*StopSandboxResponse, error) { + var resp StopSandboxResponse + if err := c.client.Call(ctx, "containerd.task.v2.Sandbox", "StopSandbox", req, &resp); err != nil { + return nil, err + } + return &resp, nil +} + +func (c *sandboxClient) UpdateSandbox(ctx context.Context, req *UpdateSandboxRequest) (*UpdateSandboxResponse, error) { + var resp UpdateSandboxResponse + if err := c.client.Call(ctx, "containerd.task.v2.Sandbox", "UpdateSandbox", req, &resp); err != nil { + return nil, err + } + return &resp, nil +} + +func (c *sandboxClient) PauseSandbox(ctx context.Context, req *PauseSandboxRequest) (*PauseSandboxResponse, error) { + var resp PauseSandboxResponse + if err := c.client.Call(ctx, "containerd.task.v2.Sandbox", "PauseSandbox", req, &resp); err != nil { + return nil, err + } + return &resp, nil +} + +func (c *sandboxClient) ResumeSandbox(ctx context.Context, req *ResumeSandboxRequest) (*ResumeSandboxResponse, error) { + var resp ResumeSandboxResponse + if err := c.client.Call(ctx, "containerd.task.v2.Sandbox", "ResumeSandbox", req, &resp); err != nil { + return nil, err + } + return &resp, nil +} + +func (c *sandboxClient) SandboxStatus(ctx context.Context, req *SandboxStatusRequest) (*SandboxStatusResponse, error) { + var resp SandboxStatusResponse + if err := c.client.Call(ctx, "containerd.task.v2.Sandbox", "SandboxStatus", req, &resp); err != nil { + return nil, err + } + return &resp, nil +} + +func (c *sandboxClient) PingSandbox(ctx context.Context, req *PingRequest) (*PingResponse, error) { + var resp PingResponse + if err := c.client.Call(ctx, "containerd.task.v2.Sandbox", "PingSandbox", req, &resp); err != nil { + return nil, err + } + return &resp, nil +} +func (m *StartSandboxRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StartSandboxRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StartSandboxRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SandboxID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SandboxID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BundlePath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BundlePath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StartSandboxResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StartSandboxResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StartSandboxResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Pid = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StopSandboxRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StopSandboxRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StopSandboxRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SandboxID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SandboxID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TimeoutSecs", wireType) + } + m.TimeoutSecs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TimeoutSecs |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StopSandboxResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StopSandboxResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StopSandboxResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UpdateSandboxRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: UpdateSandboxRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UpdateSandboxRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SandboxID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SandboxID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Resources == nil { + m.Resources = &types.Any{} + } + if err := m.Resources.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Annotations", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Annotations == nil { + m.Annotations = make(map[string]string) + } + var mapkey string + var mapvalue string + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthSandbox + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLengthSandbox + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapvalue |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return ErrInvalidLengthSandbox + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue < 0 { + return ErrInvalidLengthSandbox + } + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + } else { + iNdEx = entryPreIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.Annotations[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UpdateSandboxResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: UpdateSandboxResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UpdateSandboxResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SandboxStatusRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SandboxStatusRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SandboxStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SandboxID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SandboxID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PauseSandboxRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PauseSandboxRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PauseSandboxRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SandboxID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SandboxID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PauseSandboxResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PauseSandboxResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PauseSandboxResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ResumeSandboxRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ResumeSandboxRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ResumeSandboxRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SandboxID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SandboxID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ResumeSandboxResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ResumeSandboxResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ResumeSandboxResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SandboxStatusResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SandboxStatusResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SandboxStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Status == nil { + m.Status = &types.Any{} + } + if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PingRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PingRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PingRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SandboxID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSandbox + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthSandbox + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SandboxID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PingResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSandbox + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PingResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PingResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipSandbox(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSandbox + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipSandbox(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSandbox + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSandbox + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSandbox + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthSandbox + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupSandbox + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthSandbox + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthSandbox = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowSandbox = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupSandbox = fmt.Errorf("proto: unexpected end of group") +) diff --git a/runtime/v2/task/sandbox.proto b/runtime/v2/task/sandbox.proto new file mode 100644 index 000000000..cb7caac4e --- /dev/null +++ b/runtime/v2/task/sandbox.proto @@ -0,0 +1,98 @@ +/* + Copyright The containerd Authors. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + +syntax = "proto3"; + +package containerd.task.v2; + +import "google/protobuf/any.proto"; + +// Sandbox is an optional interface that shim may implement to support sandboxes environments. +// A typical example of sandbox is microVM or pause container - an entity that groups containers and/or +// holds resources relevant for this group. +service Sandbox { + // StartSandbox will create/start a new sandbox instance + rpc StartSandbox(StartSandboxRequest) returns (StartSandboxResponse); + + // StopSandbox will stop existing sandbox instance + rpc StopSandbox(StopSandboxRequest) returns (StopSandboxResponse); + + // Update can be used to amend the state of currently running sandbox instance (depending on + // implementation this can be used to resize/reacquire needed resources like RAM/CPU). + rpc UpdateSandbox(UpdateSandboxRequest) returns (UpdateSandboxResponse); + + // PauseSandbox will suspend currently running sandbox instance. + rpc PauseSandbox(PauseSandboxRequest) returns (PauseSandboxResponse); + + // ResumeSandbox will resuyme previously suspended sandbox instance. + rpc ResumeSandbox(ResumeSandboxRequest) returns (ResumeSandboxResponse); + + // SandboxStatus will return current status of the running sandbox instance + rpc SandboxStatus(SandboxStatusRequest) returns (SandboxStatusResponse); + + // PingSandbox is a lightweight API call to check whether sandbox alive. + rpc PingSandbox(PingRequest) returns (PingResponse); +} + +message StartSandboxRequest { + string sandbox_id = 1; + string bundle_path = 2; +} + +message StartSandboxResponse { + string pid = 1; +} + +message StopSandboxRequest { + string sandbox_id = 1; + uint32 timeout_secs = 2; +} + +message StopSandboxResponse {} + +message UpdateSandboxRequest { + string sandbox_id = 1; + google.protobuf.Any resources = 2; + map annotations = 3; +} + +message UpdateSandboxResponse {} + +message SandboxStatusRequest { + string sandbox_id = 1; +} + +message PauseSandboxRequest { + string sandbox_id = 1; +} + +message PauseSandboxResponse {} + +message ResumeSandboxRequest { + string sandbox_id = 1; +} + +message ResumeSandboxResponse {} + +message SandboxStatusResponse { + google.protobuf.Any status = 1; +} + +message PingRequest { + string sandbox_id = 1; +} + +message PingResponse {}