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

Merge pull request #1040 from crosbymichael/api-review

Browse Source 
Update GRPC APIs for consistency post review
This commit is contained in:
Stephen Day 2017-06-21 14:18:32 -07:00 committed by GitHub
commit 6fbe4bd568
64 changed files with 4157 additions and 2820 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

531
api/services/containers/containers.pb.go
View File

@ -75,9 +75,9 @@ type Container struct {
// If this field is updated, the spec and rootfs needed to updated, as well.
Image string `protobuf:"bytes,3,opt,name=image,proto3" json:"image,omitempty"`
// Runtime specifies which runtime to use for executing this container.
Runtime string `protobuf:"bytes,4,opt,name=runtime,proto3" json:"runtime,omitempty"`
Runtime *Container_Runtime `protobuf:"bytes,4,opt,name=runtime" json:"runtime,omitempty"`
// Spec to be used when creating the container. This is runtime specific.
Spec *google_protobuf1.Any `protobuf:"bytes,6,opt,name=spec" json:"spec,omitempty"`
Spec *google_protobuf1.Any `protobuf:"bytes,5,opt,name=spec" json:"spec,omitempty"`
// RootFS specifies the snapshot key to use for the container's root
// filesystem. When starting a task from this container, a caller should
// look up the mounts from the snapshot service and include those on the
@ -86,15 +86,28 @@ type Container struct {
// Snapshots referenced in this field will not be garbage collected.
//
// This field may be updated.
RootFS string `protobuf:"bytes,7,opt,name=rootfs,proto3" json:"rootfs,omitempty"`
CreatedAt time.Time `protobuf:"bytes,8,opt,name=created_at,json=createdAt,stdtime" json:"created_at"`
UpdatedAt time.Time `protobuf:"bytes,9,opt,name=updated_at,json=updatedAt,stdtime" json:"updated_at"`
RootFS string `protobuf:"bytes,6,opt,name=rootfs,proto3" json:"rootfs,omitempty"`
// CreatedAt is the time the container was first created.
CreatedAt time.Time `protobuf:"bytes,7,opt,name=created_at,json=createdAt,stdtime" json:"created_at"`
// UpdatedAt is the last time the container was mutated.
UpdatedAt time.Time `protobuf:"bytes,8,opt,name=updated_at,json=updatedAt,stdtime" json:"updated_at"`
}
func (m *Container) Reset() { *m = Container{} }
func (*Container) ProtoMessage() {}
func (*Container) Descriptor() ([]byte, []int) { return fileDescriptorContainers, []int{0} }
type Container_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 map[string]string `protobuf:"bytes,2,rep,name=options" json:"options,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (m *Container_Runtime) Reset() { *m = Container_Runtime{} }
func (*Container_Runtime) ProtoMessage() {}
func (*Container_Runtime) Descriptor() ([]byte, []int) { return fileDescriptorContainers, []int{0, 1} }
type GetContainerRequest struct {
ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
}
@ -183,16 +196,17 @@ func (*DeleteContainerRequest) ProtoMessage() {}
func (*DeleteContainerRequest) Descriptor() ([]byte, []int) { return fileDescriptorContainers, []int{9} }
func init() {
proto.RegisterType((*Container)(nil), "containerd.v1.Container")
proto.RegisterType((*GetContainerRequest)(nil), "containerd.v1.GetContainerRequest")
proto.RegisterType((*GetContainerResponse)(nil), "containerd.v1.GetContainerResponse")
proto.RegisterType((*ListContainersRequest)(nil), "containerd.v1.ListContainersRequest")
proto.RegisterType((*ListContainersResponse)(nil), "containerd.v1.ListContainersResponse")
proto.RegisterType((*CreateContainerRequest)(nil), "containerd.v1.CreateContainerRequest")
proto.RegisterType((*CreateContainerResponse)(nil), "containerd.v1.CreateContainerResponse")
proto.RegisterType((*UpdateContainerRequest)(nil), "containerd.v1.UpdateContainerRequest")
proto.RegisterType((*UpdateContainerResponse)(nil), "containerd.v1.UpdateContainerResponse")
proto.RegisterType((*DeleteContainerRequest)(nil), "containerd.v1.DeleteContainerRequest")
proto.RegisterType((*Container)(nil), "containerd.services.containers.v1.Container")
proto.RegisterType((*Container_Runtime)(nil), "containerd.services.containers.v1.Container.Runtime")
proto.RegisterType((*GetContainerRequest)(nil), "containerd.services.containers.v1.GetContainerRequest")
proto.RegisterType((*GetContainerResponse)(nil), "containerd.services.containers.v1.GetContainerResponse")
proto.RegisterType((*ListContainersRequest)(nil), "containerd.services.containers.v1.ListContainersRequest")
proto.RegisterType((*ListContainersResponse)(nil), "containerd.services.containers.v1.ListContainersResponse")
proto.RegisterType((*CreateContainerRequest)(nil), "containerd.services.containers.v1.CreateContainerRequest")
proto.RegisterType((*CreateContainerResponse)(nil), "containerd.services.containers.v1.CreateContainerResponse")
proto.RegisterType((*UpdateContainerRequest)(nil), "containerd.services.containers.v1.UpdateContainerRequest")
proto.RegisterType((*UpdateContainerResponse)(nil), "containerd.services.containers.v1.UpdateContainerResponse")
proto.RegisterType((*DeleteContainerRequest)(nil), "containerd.services.containers.v1.DeleteContainerRequest")
}
// Reference imports to suppress errors if they are not otherwise used.
@ -223,7 +237,7 @@ func NewContainersClient(cc *grpc.ClientConn) ContainersClient {
func (c *containersClient) Get(ctx context.Context, in *GetContainerRequest, opts ...grpc.CallOption) (*GetContainerResponse, error) {
out := new(GetContainerResponse)
err := grpc.Invoke(ctx, "/containerd.v1.Containers/Get", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/containerd.services.containers.v1.Containers/Get", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
@ -232,7 +246,7 @@ func (c *containersClient) Get(ctx context.Context, in *GetContainerRequest, opt
func (c *containersClient) List(ctx context.Context, in *ListContainersRequest, opts ...grpc.CallOption) (*ListContainersResponse, error) {
out := new(ListContainersResponse)
err := grpc.Invoke(ctx, "/containerd.v1.Containers/List", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/containerd.services.containers.v1.Containers/List", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
@ -241,7 +255,7 @@ func (c *containersClient) List(ctx context.Context, in *ListContainersRequest,
func (c *containersClient) Create(ctx context.Context, in *CreateContainerRequest, opts ...grpc.CallOption) (*CreateContainerResponse, error) {
out := new(CreateContainerResponse)
err := grpc.Invoke(ctx, "/containerd.v1.Containers/Create", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/containerd.services.containers.v1.Containers/Create", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
@ -250,7 +264,7 @@ func (c *containersClient) Create(ctx context.Context, in *CreateContainerReques
func (c *containersClient) Update(ctx context.Context, in *UpdateContainerRequest, opts ...grpc.CallOption) (*UpdateContainerResponse, error) {
out := new(UpdateContainerResponse)
err := grpc.Invoke(ctx, "/containerd.v1.Containers/Update", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/containerd.services.containers.v1.Containers/Update", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
@ -259,7 +273,7 @@ func (c *containersClient) Update(ctx context.Context, in *UpdateContainerReques
func (c *containersClient) Delete(ctx context.Context, in *DeleteContainerRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error) {
out := new(google_protobuf2.Empty)
err := grpc.Invoke(ctx, "/containerd.v1.Containers/Delete", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/containerd.services.containers.v1.Containers/Delete", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
@ -290,7 +304,7 @@ func _Containers_Get_Handler(srv interface{}, ctx context.Context, dec func(inte
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.v1.Containers/Get",
FullMethod: "/containerd.services.containers.v1.Containers/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ContainersServer).Get(ctx, req.(*GetContainerRequest))
@ -308,7 +322,7 @@ func _Containers_List_Handler(srv interface{}, ctx context.Context, dec func(int
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.v1.Containers/List",
FullMethod: "/containerd.services.containers.v1.Containers/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ContainersServer).List(ctx, req.(*ListContainersRequest))
@ -326,7 +340,7 @@ func _Containers_Create_Handler(srv interface{}, ctx context.Context, dec func(i
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.v1.Containers/Create",
FullMethod: "/containerd.services.containers.v1.Containers/Create",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ContainersServer).Create(ctx, req.(*CreateContainerRequest))
@ -344,7 +358,7 @@ func _Containers_Update_Handler(srv interface{}, ctx context.Context, dec func(i
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.v1.Containers/Update",
FullMethod: "/containerd.services.containers.v1.Containers/Update",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ContainersServer).Update(ctx, req.(*UpdateContainerRequest))
@ -362,7 +376,7 @@ func _Containers_Delete_Handler(srv interface{}, ctx context.Context, dec func(i
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.v1.Containers/Delete",
FullMethod: "/containerd.services.containers.v1.Containers/Delete",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ContainersServer).Delete(ctx, req.(*DeleteContainerRequest))
@ -371,7 +385,7 @@ func _Containers_Delete_Handler(srv interface{}, ctx context.Context, dec func(i
}
var _Containers_serviceDesc = grpc.ServiceDesc{
ServiceName: "containerd.v1.Containers",
ServiceName: "containerd.services.containers.v1.Containers",
HandlerType: (*ContainersServer)(nil),
Methods: []grpc.MethodDesc{
{
@ -443,44 +457,89 @@ func (m *Container) MarshalTo(dAtA []byte) (int, error) {
i = encodeVarintContainers(dAtA, i, uint64(len(m.Image)))
i += copy(dAtA[i:], m.Image)
}
if len(m.Runtime) > 0 {
if m.Runtime != nil {
dAtA[i] = 0x22
i++
i = encodeVarintContainers(dAtA, i, uint64(len(m.Runtime)))
i += copy(dAtA[i:], m.Runtime)
}
if m.Spec != nil {
dAtA[i] = 0x32
i++
i = encodeVarintContainers(dAtA, i, uint64(m.Spec.Size()))
n1, err := m.Spec.MarshalTo(dAtA[i:])
i = encodeVarintContainers(dAtA, i, uint64(m.Runtime.Size()))
n1, err := m.Runtime.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n1
}
if m.Spec != nil {
dAtA[i] = 0x2a
i++
i = encodeVarintContainers(dAtA, i, uint64(m.Spec.Size()))
n2, err := m.Spec.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n2
}
if len(m.RootFS) > 0 {
dAtA[i] = 0x3a
dAtA[i] = 0x32
i++
i = encodeVarintContainers(dAtA, i, uint64(len(m.RootFS)))
i += copy(dAtA[i:], m.RootFS)
}
dAtA[i] = 0x42
dAtA[i] = 0x3a
i++
i = encodeVarintContainers(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt)))
n2, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CreatedAt, dAtA[i:])
if err != nil {
return 0, err
}
i += n2
dAtA[i] = 0x4a
i++
i = encodeVarintContainers(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt)))
n3, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UpdatedAt, dAtA[i:])
n3, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CreatedAt, dAtA[i:])
if err != nil {
return 0, err
}
i += n3
dAtA[i] = 0x42
i++
i = encodeVarintContainers(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt)))
n4, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UpdatedAt, dAtA[i:])
if err != nil {
return 0, err
}
i += n4
return i, nil
}
func (m *Container_Runtime) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *Container_Runtime) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.Name) > 0 {
dAtA[i] = 0xa
i++
i = encodeVarintContainers(dAtA, i, uint64(len(m.Name)))
i += copy(dAtA[i:], m.Name)
}
if len(m.Options) > 0 {
for k, _ := range m.Options {
dAtA[i] = 0x12
i++
v := m.Options[k]
mapSize := 1 + len(k) + sovContainers(uint64(len(k))) + 1 + len(v) + sovContainers(uint64(len(v)))
i = encodeVarintContainers(dAtA, i, uint64(mapSize))
dAtA[i] = 0xa
i++
i = encodeVarintContainers(dAtA, i, uint64(len(k)))
i += copy(dAtA[i:], k)
dAtA[i] = 0x12
i++
i = encodeVarintContainers(dAtA, i, uint64(len(v)))
i += copy(dAtA[i:], v)
}
}
return i, nil
}
@ -526,11 +585,11 @@ func (m *GetContainerResponse) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0xa
i++
i = encodeVarintContainers(dAtA, i, uint64(m.Container.Size()))
n4, err := m.Container.MarshalTo(dAtA[i:])
n5, err := m.Container.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n4
i += n5
return i, nil
}
@ -606,11 +665,11 @@ func (m *CreateContainerRequest) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0xa
i++
i = encodeVarintContainers(dAtA, i, uint64(m.Container.Size()))
n5, err := m.Container.MarshalTo(dAtA[i:])
n6, err := m.Container.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n5
i += n6
return i, nil
}
@ -632,11 +691,11 @@ func (m *CreateContainerResponse) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0xa
i++
i = encodeVarintContainers(dAtA, i, uint64(m.Container.Size()))
n6, err := m.Container.MarshalTo(dAtA[i:])
n7, err := m.Container.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n6
i += n7
return i, nil
}
@ -658,20 +717,20 @@ func (m *UpdateContainerRequest) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0xa
i++
i = encodeVarintContainers(dAtA, i, uint64(m.Container.Size()))
n7, err := m.Container.MarshalTo(dAtA[i:])
n8, err := m.Container.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n7
i += n8
if m.UpdateMask != nil {
dAtA[i] = 0x12
i++
i = encodeVarintContainers(dAtA, i, uint64(m.UpdateMask.Size()))
n8, err := m.UpdateMask.MarshalTo(dAtA[i:])
n9, err := m.UpdateMask.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n8
i += n9
}
return i, nil
}
@ -694,11 +753,11 @@ func (m *UpdateContainerResponse) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0xa
i++
i = encodeVarintContainers(dAtA, i, uint64(m.Container.Size()))
n9, err := m.Container.MarshalTo(dAtA[i:])
n10, err := m.Container.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n9
i += n10
return i, nil
}
@ -772,8 +831,8 @@ func (m *Container) Size() (n int) {
if l > 0 {
n += 1 + l + sovContainers(uint64(l))
}
l = len(m.Runtime)
if l > 0 {
if m.Runtime != nil {
l = m.Runtime.Size()
n += 1 + l + sovContainers(uint64(l))
}
if m.Spec != nil {
@ -791,6 +850,24 @@ func (m *Container) Size() (n int) {
return n
}
func (m *Container_Runtime) Size() (n int) {
var l int
_ = l
l = len(m.Name)
if l > 0 {
n += 1 + l + sovContainers(uint64(l))
}
if len(m.Options) > 0 {
for k, v := range m.Options {
_ = k
_ = v
mapEntrySize := 1 + len(k) + sovContainers(uint64(len(k))) + 1 + len(v) + sovContainers(uint64(len(v)))
n += mapEntrySize + 1 + sovContainers(uint64(mapEntrySize))
}
}
return n
}
func (m *GetContainerRequest) Size() (n int) {
var l int
_ = l
@ -908,7 +985,7 @@ func (this *Container) String() string {
`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
`Labels:` + mapStringForLabels + `,`,
`Image:` + fmt.Sprintf("%v", this.Image) + `,`,
`Runtime:` + fmt.Sprintf("%v", this.Runtime) + `,`,
`Runtime:` + strings.Replace(fmt.Sprintf("%v", this.Runtime), "Container_Runtime", "Container_Runtime", 1) + `,`,
`Spec:` + strings.Replace(fmt.Sprintf("%v", this.Spec), "Any", "google_protobuf1.Any", 1) + `,`,
`RootFS:` + fmt.Sprintf("%v", this.RootFS) + `,`,
`CreatedAt:` + strings.Replace(strings.Replace(this.CreatedAt.String(), "Timestamp", "google_protobuf4.Timestamp", 1), `&`, ``, 1) + `,`,
@ -917,6 +994,27 @@ func (this *Container) String() string {
}, "")
return s
}
func (this *Container_Runtime) String() string {
if this == nil {
return "nil"
}
keysForOptions := make([]string, 0, len(this.Options))
for k, _ := range this.Options {
keysForOptions = append(keysForOptions, k)
}
github_com_gogo_protobuf_sortkeys.Strings(keysForOptions)
mapStringForOptions := "map[string]string{"
for _, k := range keysForOptions {
mapStringForOptions += fmt.Sprintf("%v: %v,", k, this.Options[k])
}
mapStringForOptions += "}"
s := strings.Join([]string{`&Container_Runtime{`,
`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
`Options:` + mapStringForOptions + `,`,
`}`,
}, "")
return s
}
func (this *GetContainerRequest) String() string {
if this == nil {
return "nil"
@ -1223,7 +1321,7 @@ func (m *Container) Unmarshal(dAtA []byte) error {
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Runtime", wireType)
}
var stringLen uint64
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowContainers
@ -1233,22 +1331,26 @@ func (m *Container) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
if msglen < 0 {
return ErrInvalidLengthContainers
}
postIndex := iNdEx + intStringLen
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Runtime = string(dAtA[iNdEx:postIndex])
if m.Runtime == nil {
m.Runtime = &Container_Runtime{}
}
if err := m.Runtime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 6:
case 5:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
}
@ -1281,7 +1383,7 @@ func (m *Container) Unmarshal(dAtA []byte) error {
return err
}
iNdEx = postIndex
case 7:
case 6:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field RootFS", wireType)
}
@ -1310,7 +1412,7 @@ func (m *Container) Unmarshal(dAtA []byte) error {
}
m.RootFS = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 8:
case 7:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
}
@ -1340,7 +1442,7 @@ func (m *Container) Unmarshal(dAtA []byte) error {
return err
}
iNdEx = postIndex
case 9:
case 8:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAt", wireType)
}
@ -1391,6 +1493,201 @@ func (m *Container) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *Container_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 ErrIntOverflowContainers
}
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 ErrIntOverflowContainers
}
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 ErrInvalidLengthContainers
}
postIndex := iNdEx + intStringLen
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 ErrIntOverflowContainers
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthContainers
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
var keykey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowContainers
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
keykey |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
var stringLenmapkey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowContainers
}
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 ErrInvalidLengthContainers
}
postStringIndexmapkey := iNdEx + intStringLenmapkey
if postStringIndexmapkey > l {
return io.ErrUnexpectedEOF
}
mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
iNdEx = postStringIndexmapkey
if m.Options == nil {
m.Options = make(map[string]string)
}
if iNdEx < postIndex {
var valuekey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowContainers
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
valuekey |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
var stringLenmapvalue uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowContainers
}
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 ErrInvalidLengthContainers
}
postStringIndexmapvalue := iNdEx + intStringLenmapvalue
if postStringIndexmapvalue > l {
return io.ErrUnexpectedEOF
}
mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
iNdEx = postStringIndexmapvalue
m.Options[mapkey] = mapvalue
} else {
var mapvalue string
m.Options[mapkey] = mapvalue
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipContainers(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthContainers
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *GetContainerRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
@ -2252,48 +2549,52 @@ func init() {
}
var fileDescriptorContainers = []byte{
// 680 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0xcd, 0x6e, 0xd3, 0x40,
0x10, 0xae, 0x93, 0xe0, 0x36, 0x13, 0x21, 0xa1, 0x25, 0x04, 0x63, 0xa4, 0x24, 0x32, 0x3f, 0xca,
0x05, 0x1b, 0xc2, 0x85, 0x9f, 0x0a, 0xa9, 0xe9, 0x9f, 0x2a, 0x15, 0x0e, 0x6e, 0xa1, 0xdc, 0x2a,
0x27, 0xde, 0x04, 0xab, 0x8e, 0xd7, 0x78, 0x37, 0x95, 0x72, 0xe3, 0x11, 0x90, 0x78, 0x05, 0x8e,
0x3c, 0x48, 0x8f, 0x1c, 0x39, 0x15, 0x9a, 0x27, 0x41, 0xbb, 0x5e, 0xd7, 0xa9, 0xed, 0x50, 0x10,
0xbd, 0xcd, 0x78, 0xbe, 0xf9, 0x32, 0xf3, 0xcd, 0x67, 0x07, 0x76, 0x46, 0x1e, 0xfb, 0x30, 0xe9,
0x9b, 0x03, 0x32, 0xb6, 0x06, 0x24, 0x60, 0x8e, 0x17, 0xe0, 0xc8, 0x9d, 0x0f, 0x9d, 0xd0, 0xb3,
0x28, 0x8e, 0x8e, 0xbd, 0x01, 0xa6, 0xe9, 0xf3, 0xf9, 0xd0, 0x0c, 0x23, 0xc2, 0x08, 0xba, 0x9e,
0x36, 0x99, 0xc7, 0x4f, 0xf4, 0xfa, 0x88, 0x8c, 0x88, 0xa8, 0x58, 0x3c, 0x8a, 0x41, 0xfa, 0x9d,
0x11, 0x21, 0x23, 0x1f, 0x5b, 0x22, 0xeb, 0x4f, 0x86, 0x96, 0x13, 0x4c, 0x65, 0xe9, 0x6e, 0xb6,
0x84, 0xc7, 0x21, 0x4b, 0x8a, 0xed, 0x6c, 0x71, 0xe8, 0x61, 0xdf, 0x3d, 0x1c, 0x3b, 0xf4, 0x48,
0x22, 0x5a, 0x59, 0x04, 0xf3, 0xc6, 0x98, 0x32, 0x67, 0x1c, 0x4a, 0xc0, 0xd6, 0x5f, 0xad, 0xca,
0xa6, 0x21, 0xa6, 0x96, 0x8b, 0xe9, 0x20, 0xf2, 0x42, 0x46, 0xa2, 0xb9, 0x30, 0xe6, 0x31, 0xbe,
0x96, 0xa1, 0xba, 0x9e, 0x34, 0xa1, 0x06, 0x94, 0x3c, 0x57, 0x53, 0xda, 0x4a, 0xa7, 0xda, 0x53,
0x67, 0xa7, 0xad, 0xd2, 0xce, 0x86, 0x5d, 0xf2, 0x5c, 0xb4, 0x0a, 0xaa, 0xef, 0xf4, 0xb1, 0x4f,
0xb5, 0x52, 0xbb, 0xdc, 0xa9, 0x75, 0xef, 0x9b, 0x17, 0xe4, 0x31, 0xcf, 0x19, 0xcc, 0x5d, 0x01,
0xdb, 0x0c, 0x58, 0x34, 0xb5, 0x65, 0x0f, 0xaa, 0xc3, 0x35, 0x6f, 0xec, 0x8c, 0xb0, 0x56, 0xe6,
0xc4, 0x76, 0x9c, 0x20, 0x0d, 0x96, 0xa3, 0x49, 0xc0, 0xf7, 0xd2, 0x2a, 0xe2, 0x79, 0x92, 0xa2,
0x0e, 0x54, 0x68, 0x88, 0x07, 0x9a, 0xda, 0x56, 0x3a, 0xb5, 0x6e, 0xdd, 0x8c, 0xb5, 0x30, 0x13,
0x2d, 0xcc, 0xb5, 0x60, 0x6a, 0x0b, 0x04, 0x32, 0x40, 0x8d, 0x08, 0x61, 0x43, 0xaa, 0x2d, 0x8b,
0x99, 0x61, 0x76, 0xda, 0x52, 0x6d, 0x42, 0xd8, 0xd6, 0x9e, 0x2d, 0x2b, 0x68, 0x1d, 0x60, 0x10,
0x61, 0x87, 0x61, 0xf7, 0xd0, 0x61, 0xda, 0x8a, 0xe0, 0xd4, 0x73, 0x9c, 0xfb, 0x89, 0xbe, 0xbd,
0x95, 0x93, 0xd3, 0xd6, 0xd2, 0xe7, 0x9f, 0x2d, 0xc5, 0xae, 0xca, 0xbe, 0x35, 0xc6, 0x49, 0x26,
0xa1, 0x9b, 0x90, 0x54, 0xff, 0x85, 0x44, 0xf6, 0xad, 0x31, 0xfd, 0x39, 0xd4, 0xe6, 0xe4, 0x41,
0x37, 0xa0, 0x7c, 0x84, 0xa7, 0xb1, 0xda, 0x36, 0x0f, 0xb9, 0x50, 0xc7, 0x8e, 0x3f, 0xc1, 0x5a,
0x29, 0x16, 0x4a, 0x24, 0x2f, 0x4a, 0xcf, 0x14, 0xe3, 0x11, 0xdc, 0xdc, 0xc6, 0xec, 0x5c, 0x66,
0x1b, 0x7f, 0x9c, 0x60, 0xca, 0x16, 0xdd, 0xcb, 0xd8, 0x87, 0xfa, 0x45, 0x38, 0x0d, 0x49, 0x40,
0x31, 0x5a, 0x85, 0xea, 0xf9, 0xe1, 0x44, 0x5b, 0xad, 0xab, 0x2d, 0x3a, 0x65, 0xaf, 0xc2, 0x77,
0xb0, 0xd3, 0x06, 0xc3, 0x82, 0x5b, 0xbb, 0x1e, 0x4d, 0x69, 0x69, 0x3a, 0x86, 0x3a, 0xf4, 0x7c,
0x26, 0x39, 0xab, 0xb6, 0xcc, 0x8c, 0xf7, 0xd0, 0xc8, 0x36, 0xc8, 0x41, 0x5e, 0x01, 0xa4, 0xaf,
0x9c, 0xa6, 0x08, 0x53, 0x5d, 0x36, 0xc9, 0x5c, 0x87, 0xf1, 0x0e, 0x1a, 0xeb, 0xe2, 0x38, 0x39,
0x49, 0xfe, 0x6f, 0xc5, 0x03, 0xb8, 0x9d, 0xe3, 0xbd, 0x12, 0xed, 0xbe, 0x28, 0xd0, 0x78, 0x2b,
0x9c, 0x70, 0xb5, 0x13, 0xa3, 0x97, 0x50, 0x8b, 0x1d, 0x26, 0x3e, 0x1f, 0xc2, 0x39, 0x45, 0xd6,
0xdc, 0xe2, 0x5f, 0x98, 0xd7, 0x0e, 0x3d, 0xb2, 0xa5, 0x91, 0x79, 0xcc, 0xd7, 0xcd, 0x0d, 0x75,
0x25, 0xeb, 0x3e, 0x86, 0xc6, 0x06, 0xf6, 0x71, 0xc1, 0xb6, 0x0b, 0x2c, 0xdb, 0xfd, 0x56, 0x06,
0x48, 0x8d, 0x82, 0xde, 0x40, 0x79, 0x1b, 0x33, 0x64, 0x64, 0x7e, 0xb2, 0xe0, 0x25, 0xd0, 0xef,
0xfd, 0x11, 0x23, 0xd7, 0xd9, 0x83, 0x0a, 0xb7, 0x22, 0xca, 0x7e, 0xb9, 0x0a, 0x0d, 0xad, 0x3f,
0xb8, 0x04, 0x25, 0x49, 0x0f, 0x40, 0x8d, 0xdd, 0x82, 0xb2, 0x0d, 0xc5, 0xe6, 0xd4, 0x1f, 0x5e,
0x06, 0x4b, 0x89, 0xe3, 0xbb, 0xe4, 0x88, 0x8b, 0x3d, 0x94, 0x23, 0x5e, 0x74, 0xd5, 0x6d, 0x50,
0xe3, 0xbb, 0xe4, 0x88, 0x8b, 0xcf, 0xa5, 0x37, 0x72, 0x4e, 0xda, 0xe4, 0x7f, 0x64, 0x3d, 0xed,
0xe4, 0xac, 0xb9, 0xf4, 0xe3, 0xac, 0xb9, 0xf4, 0x69, 0xd6, 0x54, 0x4e, 0x66, 0x4d, 0xe5, 0xfb,
0xac, 0xa9, 0xfc, 0x9a, 0x35, 0x95, 0xbe, 0x2a, 0x90, 0x4f, 0x7f, 0x07, 0x00, 0x00, 0xff, 0xff,
0xc1, 0x18, 0xeb, 0x02, 0x8d, 0x07, 0x00, 0x00,
// 745 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0xcd, 0x6e, 0xda, 0x4a,
0x14, 0x8e, 0x81, 0x98, 0x70, 0xb8, 0x8b, 0xab, 0xb9, 0x5c, 0xae, 0xaf, 0x2b, 0x01, 0x65, 0xc5,
0xa2, 0x35, 0x2d, 0xad, 0xda, 0x24, 0x5d, 0x41, 0xfe, 0x14, 0x29, 0x6d, 0xa3, 0x69, 0xbb, 0xca,
0x22, 0x32, 0x30, 0x10, 0x17, 0xe3, 0x71, 0x3d, 0x03, 0x12, 0xea, 0xa2, 0x7d, 0x84, 0xbe, 0x45,
0xde, 0xa0, 0xcf, 0x90, 0x65, 0x97, 0x5d, 0xa5, 0x09, 0x4f, 0x52, 0x79, 0x3c, 0x8e, 0x29, 0x38,
0xaa, 0x41, 0xcd, 0xee, 0x4c, 0xe6, 0x7c, 0xdf, 0xf9, 0xe6, 0x3b, 0xe7, 0x38, 0xc0, 0x61, 0xdf,
0xe2, 0x67, 0xa3, 0xb6, 0xd1, 0xa1, 0xc3, 0x7a, 0x87, 0x3a, 0xdc, 0xb4, 0x1c, 0xe2, 0x75, 0x67,
0x43, 0xd3, 0xb5, 0xea, 0x8c, 0x78, 0x63, 0xab, 0x43, 0x58, 0xf4, 0xf7, 0xd9, 0xd0, 0x70, 0x3d,
0xca, 0x29, 0xba, 0x1f, 0x81, 0x8c, 0x10, 0x60, 0xcc, 0x64, 0x8d, 0x1f, 0xeb, 0x85, 0x3e, 0xed,
0x53, 0x91, 0x5d, 0xf7, 0xa3, 0x00, 0xa8, 0xff, 0xdf, 0xa7, 0xb4, 0x6f, 0x93, 0xba, 0x38, 0xb5,
0x47, 0xbd, 0xba, 0xe9, 0x4c, 0xe4, 0xd5, 0xbd, 0xf9, 0x2b, 0x32, 0x74, 0x79, 0x78, 0x59, 0x99,
0xbf, 0xec, 0x59, 0xc4, 0xee, 0x9e, 0x0e, 0x4d, 0x36, 0x90, 0x19, 0xe5, 0xf9, 0x0c, 0x6e, 0x0d,
0x09, 0xe3, 0xe6, 0xd0, 0x95, 0x09, 0xfb, 0x89, 0x9e, 0xcf, 0x27, 0x2e, 0x61, 0xf5, 0x2e, 0x61,
0x1d, 0xcf, 0x72, 0x39, 0xf5, 0x66, 0xc2, 0x80, 0xa7, 0x7a, 0xbe, 0x0e, 0xb9, 0x9d, 0x10, 0x84,
0x8a, 0x90, 0xb2, 0xba, 0x9a, 0x52, 0x51, 0x6a, 0xb9, 0x96, 0x3a, 0xbd, 0x2c, 0xa7, 0x0e, 0x77,
0x71, 0xca, 0xea, 0xa2, 0x63, 0x50, 0x6d, 0xb3, 0x4d, 0x6c, 0xa6, 0xa5, 0x2a, 0xe9, 0x5a, 0xbe,
0xb1, 0x69, 0xfc, 0xd6, 0x32, 0xe3, 0x86, 0xd5, 0x38, 0x12, 0xd0, 0x3d, 0x87, 0x7b, 0x13, 0x2c,
0x79, 0x50, 0x01, 0xd6, 0xad, 0xa1, 0xd9, 0x27, 0x5a, 0xda, 0x2f, 0x86, 0x83, 0x03, 0x7a, 0x05,
0x59, 0x6f, 0xe4, 0xf8, 0x6f, 0xd5, 0x32, 0x15, 0xa5, 0x96, 0x6f, 0x3c, 0x5d, 0xaa, 0x10, 0x0e,
0xb0, 0x38, 0x24, 0x41, 0x35, 0xc8, 0x30, 0x97, 0x74, 0xb4, 0x75, 0x41, 0x56, 0x30, 0x02, 0x57,
0x8d, 0xd0, 0x55, 0xa3, 0xe9, 0x4c, 0xb0, 0xc8, 0x40, 0x55, 0x50, 0x3d, 0x4a, 0x79, 0x8f, 0x69,
0xaa, 0x78, 0x3d, 0x4c, 0x2f, 0xcb, 0x2a, 0xa6, 0x94, 0xef, 0xbf, 0xc1, 0xf2, 0x06, 0xed, 0x00,
0x74, 0x3c, 0x62, 0x72, 0xd2, 0x3d, 0x35, 0xb9, 0x96, 0x15, 0x9c, 0xfa, 0x02, 0xe7, 0xdb, 0xb0,
0x53, 0xad, 0x8d, 0x8b, 0xcb, 0xf2, 0xda, 0x97, 0x1f, 0x65, 0x05, 0xe7, 0x24, 0xae, 0xc9, 0x7d,
0x92, 0x91, 0xdb, 0x0d, 0x49, 0x36, 0x96, 0x21, 0x91, 0xb8, 0x26, 0xd7, 0xb7, 0x20, 0x3f, 0x63,
0x2a, 0xfa, 0x1b, 0xd2, 0x03, 0x32, 0x09, 0xfa, 0x86, 0xfd, 0xd0, 0xb7, 0x77, 0x6c, 0xda, 0x23,
0xa2, 0xa5, 0x02, 0x7b, 0xc5, 0x61, 0x3b, 0xb5, 0xa9, 0xe8, 0x5f, 0x15, 0xc8, 0x4a, 0x9f, 0x10,
0x82, 0x8c, 0x63, 0x0e, 0x89, 0x04, 0x8a, 0x18, 0x9d, 0x40, 0x96, 0xba, 0xdc, 0xa2, 0x4e, 0xd8,
0xeb, 0xe6, 0x2a, 0x2d, 0x30, 0x5e, 0x07, 0x1c, 0x41, 0xd3, 0x43, 0x46, 0x7d, 0x1b, 0xfe, 0x9a,
0xbd, 0x58, 0x46, 0x78, 0xf5, 0x21, 0xfc, 0x73, 0x40, 0xf8, 0x4d, 0x25, 0x4c, 0x3e, 0x8c, 0x08,
0xe3, 0xb7, 0x8d, 0x6c, 0xf5, 0x0c, 0x0a, 0xbf, 0xa6, 0x33, 0x97, 0x3a, 0x8c, 0xa0, 0x63, 0xc8,
0xdd, 0x68, 0x17, 0xb0, 0x7c, 0xe3, 0xc1, 0x32, 0x2f, 0x6c, 0x65, 0xfc, 0x86, 0xe0, 0x88, 0xa4,
0x5a, 0x87, 0x7f, 0x8f, 0x2c, 0x16, 0x95, 0x62, 0x91, 0x34, 0xb5, 0x67, 0xd9, 0x5c, 0xd6, 0xc9,
0x61, 0x79, 0xaa, 0xda, 0x50, 0x9c, 0x07, 0x48, 0x71, 0x18, 0x20, 0x2a, 0xab, 0x29, 0xc2, 0xff,
0x55, 0xd4, 0xcd, 0xb0, 0x54, 0xdf, 0x43, 0x71, 0x47, 0x4c, 0xdf, 0x82, 0x75, 0x7f, 0xde, 0x8a,
0x01, 0xfc, 0xb7, 0x50, 0xeb, 0xce, 0x7c, 0x3f, 0x57, 0xa0, 0xf8, 0x4e, 0xac, 0xc4, 0xdd, 0xbf,
0x0c, 0xbd, 0x80, 0x7c, 0xb0, 0x7e, 0xe2, 0x2b, 0x2d, 0xa6, 0x33, 0x6e, 0x6f, 0xf7, 0xfd, 0x0f,
0xf9, 0x4b, 0x93, 0x0d, 0xb0, 0xdc, 0x72, 0x3f, 0xf6, 0x6d, 0x59, 0x10, 0x7a, 0x67, 0xb6, 0x3c,
0x82, 0xe2, 0x2e, 0xb1, 0x49, 0x8c, 0x2b, 0xb7, 0xac, 0x4a, 0xe3, 0x2a, 0x03, 0x10, 0x0d, 0x23,
0x1a, 0x43, 0xfa, 0x80, 0x70, 0xf4, 0x2c, 0x81, 0x8c, 0x98, 0x85, 0xd4, 0x9f, 0x2f, 0x8d, 0x93,
0x56, 0x7c, 0x84, 0x8c, 0xbf, 0x16, 0x28, 0xc9, 0x3f, 0x97, 0xd8, 0x85, 0xd3, 0xb7, 0x56, 0x40,
0xca, 0xe2, 0x9f, 0x40, 0x0d, 0x26, 0x17, 0x25, 0x21, 0x89, 0x5f, 0x28, 0x7d, 0x7b, 0x15, 0x68,
0x24, 0x20, 0x98, 0x91, 0x44, 0x02, 0xe2, 0xe7, 0x3e, 0x91, 0x80, 0xdb, 0x26, 0xf1, 0x04, 0xd4,
0x60, 0x6e, 0x12, 0x09, 0x88, 0x1f, 0x31, 0xbd, 0xb8, 0xb0, 0x11, 0x7b, 0xfe, 0xef, 0x9e, 0x96,
0x76, 0x71, 0x5d, 0x5a, 0xfb, 0x7e, 0x5d, 0x5a, 0xfb, 0x3c, 0x2d, 0x29, 0x17, 0xd3, 0x92, 0xf2,
0x6d, 0x5a, 0x52, 0xae, 0xa6, 0x25, 0xa5, 0xad, 0x8a, 0xcc, 0x27, 0x3f, 0x03, 0x00, 0x00, 0xff,
0xff, 0xcd, 0xae, 0xd0, 0xb5, 0xd0, 0x09, 0x00, 0x00,
}

21
api/services/containers/containers.proto
View File

@ -1,6 +1,6 @@
syntax = "proto3";
package containerd.v1;
package containerd.services.containers.v1;
import "gogoproto/gogo.proto";
import "google/protobuf/any.proto";
@ -51,11 +51,17 @@ message Container {
// If this field is updated, the spec and rootfs needed to updated, as well.
string image = 3;
message Runtime {
// Name is the name of the runtime.
string name = 1;
// Options specify additional runtime initialization options.
map<string, string> options = 2;
}
// Runtime specifies which runtime to use for executing this container.
string runtime = 4;
Runtime runtime = 4;
// Spec to be used when creating the container. This is runtime specific.
google.protobuf.Any spec = 6;
google.protobuf.Any spec = 5;
// RootFS specifies the snapshot key to use for the container's root
// filesystem. When starting a task from this container, a caller should
@ -65,10 +71,13 @@ message Container {
// Snapshots referenced in this field will not be garbage collected.
//
// This field may be updated.
string rootfs = 7 [(gogoproto.customname) = "RootFS"];
string rootfs = 6 [(gogoproto.customname) = "RootFS"];
google.protobuf.Timestamp created_at = 8 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
google.protobuf.Timestamp updated_at = 9 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
// CreatedAt is the time the container was first created.
google.protobuf.Timestamp created_at = 7 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
// UpdatedAt is the last time the container was mutated.
google.protobuf.Timestamp updated_at = 8 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
}
message GetContainerRequest {

585
api/services/content/content.pb.go
View File

File diff suppressed because it is too large Load Diff

30
api/services/content/content.proto
View File

@ -1,6 +1,6 @@
syntax = "proto3";
package containerd.v1;
package containerd.services.content.v1;
import "gogoproto/gogo.proto";
import "google/protobuf/timestamp.proto";
@ -28,7 +28,7 @@ service Content {
// Read allows one to read an object based on the offset into the content.
//
// The requested data may be returned in one or more messages.
rpc Read(ReadRequest) returns (stream ReadResponse);
rpc Read(ReadContentRequest) returns (stream ReadContentResponse);
// Status returns the status of ongoing object ingestions, started via
// Write.
@ -54,7 +54,7 @@ service Content {
//
// When completed, the commit flag should be set to true. If expected size
// or digest is set, the content will be validated against those values.
rpc Write(stream WriteRequest) returns (stream WriteResponse);
rpc Write(stream WriteContentRequest) returns (stream WriteContentResponse);
// Abort cancels the ongoing write named in the request. Any resources
// associated with the write will be collected.
@ -91,9 +91,9 @@ message DeleteContentRequest {
string digest = 1 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false];
}
// ReadRequest defines the fields that make up a request to read a portion of
// ReadContentRequest defines the fields that make up a request to read a portion of
// data from a stored object.
message ReadRequest {
message ReadContentRequest {
// Digest is the hash identity to read.
string digest = 1 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false];
@ -107,16 +107,12 @@ message ReadRequest {
int64 size = 3;
}
// ReadResponse carries byte data for a read request.
message ReadResponse {
// ReadContentResponse carries byte data for a read request.
message ReadContentResponse {
int64 offset = 1; // offset of the returned data
bytes data = 2; // actual data
}
message StatusRequest {
string regexp = 1;
}
message Status {
google.protobuf.Timestamp started_at = 1 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
google.protobuf.Timestamp updated_at = 2 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
@ -126,6 +122,10 @@ message Status {
string expected = 6 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false];
}
message StatusRequest {
string filter = 1;
}
message StatusResponse {
repeated Status statuses = 1 [(gogoproto.nullable) = false];
}
@ -157,8 +157,8 @@ enum WriteAction {
COMMIT = 2 [(gogoproto.enumvalue_customname) = "WriteActionCommit"];
}
// WriteRequest writes data to the request ref at offset.
message WriteRequest {
// WriteContentRequest writes data to the request ref at offset.
message WriteContentRequest {
// Action sets the behavior of the write.
//
// When this is a write and the ref is not yet allocated, the ref will be
@ -215,8 +215,8 @@ message WriteRequest {
bytes data = 6;
}
// WriteResponse is returned on the culmination of a write call.
message WriteResponse {
// WriteContentResponse is returned on the culmination of a write call.
message WriteContentResponse {
// Action contains the action for the final message of the stream. A writer
// should confirm that they match the intended result.
WriteAction action = 1;

73
api/services/diff/diff.pb.go
View File

@ -96,10 +96,10 @@ func (*DiffResponse) ProtoMessage() {}
func (*DiffResponse) Descriptor() ([]byte, []int) { return fileDescriptorDiff, []int{3} }
func init() {
proto.RegisterType((*ApplyRequest)(nil), "containerd.v1.ApplyRequest")
proto.RegisterType((*ApplyResponse)(nil), "containerd.v1.ApplyResponse")
proto.RegisterType((*DiffRequest)(nil), "containerd.v1.DiffRequest")
proto.RegisterType((*DiffResponse)(nil), "containerd.v1.DiffResponse")
proto.RegisterType((*ApplyRequest)(nil), "containerd.services.diff.v1.ApplyRequest")
proto.RegisterType((*ApplyResponse)(nil), "containerd.services.diff.v1.ApplyResponse")
proto.RegisterType((*DiffRequest)(nil), "containerd.services.diff.v1.DiffRequest")
proto.RegisterType((*DiffResponse)(nil), "containerd.services.diff.v1.DiffResponse")
}
// Reference imports to suppress errors if they are not otherwise used.
@ -132,7 +132,7 @@ func NewDiffClient(cc *grpc.ClientConn) DiffClient {
func (c *diffClient) Apply(ctx context.Context, in *ApplyRequest, opts ...grpc.CallOption) (*ApplyResponse, error) {
out := new(ApplyResponse)
err := grpc.Invoke(ctx, "/containerd.v1.Diff/Apply", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/containerd.services.diff.v1.Diff/Apply", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
@ -141,7 +141,7 @@ func (c *diffClient) Apply(ctx context.Context, in *ApplyRequest, opts ...grpc.C
func (c *diffClient) Diff(ctx context.Context, in *DiffRequest, opts ...grpc.CallOption) (*DiffResponse, error) {
out := new(DiffResponse)
err := grpc.Invoke(ctx, "/containerd.v1.Diff/Diff", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/containerd.services.diff.v1.Diff/Diff", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
@ -174,7 +174,7 @@ func _Diff_Apply_Handler(srv interface{}, ctx context.Context, dec func(interfac
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.v1.Diff/Apply",
FullMethod: "/containerd.services.diff.v1.Diff/Apply",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DiffServer).Apply(ctx, req.(*ApplyRequest))
@ -192,7 +192,7 @@ func _Diff_Diff_Handler(srv interface{}, ctx context.Context, dec func(interface
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.v1.Diff/Diff",
FullMethod: "/containerd.services.diff.v1.Diff/Diff",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DiffServer).Diff(ctx, req.(*DiffRequest))
@ -201,7 +201,7 @@ func _Diff_Diff_Handler(srv interface{}, ctx context.Context, dec func(interface
}
var _Diff_serviceDesc = grpc.ServiceDesc{
ServiceName: "containerd.v1.Diff",
ServiceName: "containerd.services.diff.v1.Diff",
HandlerType: (*DiffServer)(nil),
Methods: []grpc.MethodDesc{
{
@ -1081,31 +1081,32 @@ func init() {
}
var fileDescriptorDiff = []byte{
// 407 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x52, 0x41, 0xcf, 0x93, 0x40,
0x10, 0xfd, 0x56, 0xda, 0xcf, 0x74, 0xdb, 0x26, 0x66, 0xe3, 0x81, 0x50, 0xa5, 0x0d, 0xa7, 0x9e,
0x40, 0xe9, 0xc9, 0x44, 0x63, 0xac, 0x8d, 0x07, 0x13, 0x2f, 0xc4, 0xbb, 0xa1, 0x30, 0xd0, 0x4d,
0x80, 0x5d, 0xd9, 0xa5, 0x86, 0x9b, 0x77, 0xff, 0x84, 0x3f, 0xa7, 0x47, 0x8f, 0x1e, 0x2d, 0xbf,
0xc4, 0xb0, 0x6c, 0x15, 0x9b, 0x26, 0xb6, 0x97, 0xcd, 0xb0, 0xef, 0xcd, 0x9b, 0x37, 0x8f, 0xc5,
0xaf, 0x52, 0x2a, 0x77, 0xd5, 0xd6, 0x8d, 0x58, 0xee, 0x45, 0xac, 0x90, 0x21, 0x2d, 0xa0, 0x8c,
0xfb, 0x65, 0xc8, 0xa9, 0x27, 0xa0, 0xdc, 0xd3, 0x08, 0x84, 0x17, 0xd3, 0x24, 0x51, 0x87, 0xcb,
0x4b, 0x26, 0x19, 0x99, 0xfe, 0x25, 0xba, 0xfb, 0xe7, 0xd6, 0xe3, 0x94, 0xa5, 0x4c, 0x21, 0x5e,
0x5b, 0x75, 0x24, 0x6b, 0x96, 0x32, 0x96, 0x66, 0xe0, 0xa9, 0xaf, 0x6d, 0x95, 0x78, 0x90, 0x73,
0x59, 0x6b, 0x70, 0x7e, 0x0e, 0x4a, 0x9a, 0x83, 0x90, 0x61, 0xce, 0x35, 0xe1, 0xe5, 0x55, 0x0e,
0x65, 0xcd, 0x41, 0x78, 0x39, 0xab, 0x0a, 0xd9, 0x9d, 0xba, 0xfb, 0xdd, 0x0d, 0xdd, 0x31, 0x88,
0xa8, 0xa4, 0x5c, 0xb2, 0xb2, 0x57, 0x76, 0x3a, 0xce, 0x17, 0x3c, 0x79, 0xc3, 0x79, 0x56, 0x07,
0xf0, 0xb9, 0x02, 0x21, 0xc9, 0x0a, 0x0f, 0xda, 0x18, 0x4c, 0xb4, 0x40, 0xcb, 0xb1, 0x3f, 0x77,
0xff, 0xc9, 0xc1, 0x55, 0x7a, 0xee, 0xe6, 0x8f, 0x48, 0xa0, 0xc8, 0xc4, 0xc7, 0xf7, 0xca, 0x9b,
0x30, 0x1f, 0x2c, 0x8c, 0xe5, 0xd8, 0xb7, 0x2e, 0xb6, 0x7d, 0x68, 0x29, 0x81, 0x66, 0x3a, 0xef,
0xf1, 0x54, 0x0f, 0x16, 0x9c, 0x15, 0x02, 0xc8, 0x0b, 0xfc, 0x30, 0xe4, 0x3c, 0xa3, 0x10, 0x5f,
0x3b, 0xfc, 0xc4, 0x77, 0xbe, 0x23, 0x3c, 0xde, 0xd0, 0x24, 0x39, 0x2d, 0xe1, 0xe2, 0x41, 0x06,
0x89, 0x34, 0xd1, 0x7f, 0xdd, 0x28, 0x1e, 0x79, 0x86, 0x87, 0x25, 0x4d, 0x77, 0xf2, 0x0a, 0xfb,
0x1d, 0x91, 0x3c, 0xc5, 0x38, 0x87, 0x98, 0x86, 0x9f, 0x5a, 0xcc, 0x34, 0x16, 0x68, 0x39, 0x0a,
0x46, 0xea, 0xe6, 0x63, 0xcd, 0x81, 0x3c, 0xc2, 0x46, 0x09, 0x89, 0x39, 0x54, 0xf7, 0x6d, 0xe9,
0xbc, 0xc5, 0x93, 0xce, 0xa1, 0xde, 0xf6, 0x94, 0xb3, 0x71, 0x43, 0xce, 0xfe, 0x37, 0x84, 0x07,
0xad, 0x0a, 0x59, 0xe3, 0xa1, 0x0a, 0x8f, 0xcc, 0xce, 0x1a, 0xfb, 0xff, 0xd2, 0x7a, 0x72, 0x19,
0xd4, 0x0e, 0x5e, 0x6b, 0xad, 0xf3, 0x6d, 0x7b, 0x41, 0x5a, 0xb3, 0x8b, 0x58, 0x27, 0xb0, 0x36,
0x0f, 0x47, 0xfb, 0xee, 0xe7, 0xd1, 0xbe, 0xfb, 0xda, 0xd8, 0xe8, 0xd0, 0xd8, 0xe8, 0x47, 0x63,
0xa3, 0x5f, 0x8d, 0x8d, 0xb6, 0xf7, 0xea, 0x6d, 0xad, 0x7e, 0x07, 0x00, 0x00, 0xff, 0xff, 0x61,
0x65, 0x17, 0x47, 0x85, 0x03, 0x00, 0x00,
// 420 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0x31, 0x8f, 0x94, 0x40,
0x14, 0xc7, 0x6f, 0x64, 0xf7, 0xcc, 0xcd, 0x9e, 0x89, 0x99, 0x58, 0x10, 0x2e, 0x72, 0x1b, 0x2a,
0xce, 0x62, 0xf0, 0xb8, 0xca, 0x44, 0x0b, 0xf5, 0x62, 0x61, 0x62, 0x43, 0xec, 0x4c, 0x34, 0x2c,
0x3c, 0xb8, 0x49, 0x80, 0x19, 0x99, 0x61, 0x0d, 0x9d, 0x1f, 0xc5, 0xef, 0x62, 0x73, 0xa5, 0xa5,
0xa5, 0xcb, 0x27, 0x31, 0x0c, 0x83, 0x12, 0x63, 0xf6, 0xd8, 0x66, 0xf2, 0x98, 0xf7, 0x7b, 0xef,
0xfd, 0xdf, 0x9f, 0xc1, 0x2f, 0x72, 0xa6, 0x6e, 0x9a, 0x0d, 0x4d, 0x78, 0x19, 0x24, 0xbc, 0x52,
0x31, 0xab, 0xa0, 0x4e, 0xa7, 0x61, 0x2c, 0x58, 0x20, 0xa1, 0xde, 0xb2, 0x04, 0x64, 0x90, 0xb2,
0x2c, 0xd3, 0x07, 0x15, 0x35, 0x57, 0x9c, 0x9c, 0xfd, 0x05, 0xe9, 0x08, 0x51, 0x9d, 0xdf, 0x5e,
0x3a, 0x8f, 0x72, 0x9e, 0x73, 0xcd, 0x05, 0x7d, 0x34, 0x94, 0x38, 0x67, 0x39, 0xe7, 0x79, 0x01,
0x81, 0xfe, 0xda, 0x34, 0x59, 0x00, 0xa5, 0x50, 0xad, 0x49, 0x9e, 0xff, 0x9b, 0x54, 0xac, 0x04,
0xa9, 0xe2, 0x52, 0x18, 0xe0, 0xf9, 0x2c, 0xbd, 0xaa, 0x15, 0x20, 0x83, 0x92, 0x37, 0x95, 0x1a,
0x4e, 0x53, 0xfd, 0xe6, 0x80, 0xea, 0x14, 0x64, 0x52, 0x33, 0xa1, 0x78, 0x3d, 0x09, 0x87, 0x3e,
0xde, 0x17, 0x7c, 0xfa, 0x52, 0x88, 0xa2, 0x8d, 0xe0, 0x73, 0x03, 0x52, 0x91, 0x2b, 0xbc, 0xe8,
0x97, 0xb6, 0xd1, 0x1a, 0xf9, 0xab, 0xf0, 0x9c, 0x4e, 0x5c, 0xd9, 0x5e, 0x52, 0xdd, 0x8f, 0x5e,
0xff, 0x69, 0x12, 0x69, 0x98, 0x84, 0xf8, 0x58, 0x6b, 0x93, 0xf6, 0xbd, 0xb5, 0xe5, 0xaf, 0x42,
0xe7, 0xbf, 0x65, 0xef, 0x7a, 0x24, 0x32, 0xa4, 0xf7, 0x16, 0x3f, 0x30, 0x83, 0xa5, 0xe0, 0x95,
0x04, 0xf2, 0x0c, 0xdf, 0x8f, 0x85, 0x28, 0x18, 0xa4, 0x73, 0x87, 0x8f, 0xbc, 0xf7, 0x0d, 0xe1,
0xd5, 0x35, 0xcb, 0xb2, 0x71, 0x09, 0x8a, 0x17, 0x05, 0x64, 0xca, 0x46, 0x77, 0xaa, 0xd1, 0x1c,
0x79, 0x8a, 0x97, 0x35, 0xcb, 0x6f, 0xd4, 0x0c, 0xf9, 0x03, 0x48, 0x1e, 0x63, 0x5c, 0x42, 0xca,
0xe2, 0x4f, 0x7d, 0xce, 0xb6, 0xd6, 0xc8, 0x3f, 0x89, 0x4e, 0xf4, 0xcd, 0xfb, 0x56, 0x00, 0x79,
0x88, 0xad, 0x1a, 0x32, 0x7b, 0xa9, 0xef, 0xfb, 0xd0, 0x7b, 0x8d, 0x4f, 0x07, 0x85, 0x66, 0xdb,
0xd1, 0x67, 0xeb, 0x00, 0x9f, 0xc3, 0xef, 0x08, 0x2f, 0xfa, 0x2e, 0xe4, 0x23, 0x5e, 0x6a, 0xf3,
0xc8, 0x05, 0xdd, 0xf3, 0x6c, 0xe9, 0xf4, 0xcf, 0x3a, 0x4f, 0xe6, 0xa0, 0x46, 0xdd, 0x07, 0x33,
0xc7, 0xdf, 0x5b, 0x33, 0xb1, 0xdc, 0xb9, 0x98, 0x41, 0x0e, 0xcd, 0x5f, 0xd9, 0xb7, 0x3b, 0xf7,
0xe8, 0xe7, 0xce, 0x3d, 0xfa, 0xda, 0xb9, 0xe8, 0xb6, 0x73, 0xd1, 0x8f, 0xce, 0x45, 0xbf, 0x3a,
0x17, 0x6d, 0x8e, 0xf5, 0x9b, 0xbc, 0xfa, 0x1d, 0x00, 0x00, 0xff, 0xff, 0x7f, 0xee, 0xae, 0xcf,
0xcb, 0x03, 0x00, 0x00,
}

2
api/services/diff/diff.proto
View File

@ -1,6 +1,6 @@
syntax = "proto3";
package containerd.v1;
package containerd.services.diff.v1;
import "gogoproto/gogo.proto";
import "google/protobuf/empty.proto";

81
api/services/events/events.pb.go
View File

@ -9,7 +9,7 @@
github.com/containerd/containerd/api/services/events/events.proto
It has these top-level messages:
EventStreamRequest
StreamEventsRequest
*/
package events
@ -39,15 +39,15 @@ var _ = math.Inf
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
type EventStreamRequest struct {
type StreamEventsRequest struct {
}
func (m *EventStreamRequest) Reset() { *m = EventStreamRequest{} }
func (*EventStreamRequest) ProtoMessage() {}
func (*EventStreamRequest) Descriptor() ([]byte, []int) { return fileDescriptorEvents, []int{0} }
func (m *StreamEventsRequest) Reset() { *m = StreamEventsRequest{} }
func (*StreamEventsRequest) ProtoMessage() {}
func (*StreamEventsRequest) Descriptor() ([]byte, []int) { return fileDescriptorEvents, []int{0} }
func init() {
proto.RegisterType((*EventStreamRequest)(nil), "containerd.v1.services.events.EventStreamRequest")
proto.RegisterType((*StreamEventsRequest)(nil), "containerd.services.events.v1.StreamEventsRequest")
}
// Reference imports to suppress errors if they are not otherwise used.
@ -61,7 +61,7 @@ const _ = grpc.SupportPackageIsVersion4
// Client API for Events service
type EventsClient interface {
EventStream(ctx context.Context, in *EventStreamRequest, opts ...grpc.CallOption) (Events_EventStreamClient, error)
Stream(ctx context.Context, in *StreamEventsRequest, opts ...grpc.CallOption) (Events_StreamClient, error)
}
type eventsClient struct {
@ -72,12 +72,12 @@ func NewEventsClient(cc *grpc.ClientConn) EventsClient {
return &eventsClient{cc}
}
func (c *eventsClient) EventStream(ctx context.Context, in *EventStreamRequest, opts ...grpc.CallOption) (Events_EventStreamClient, error) {
stream, err := grpc.NewClientStream(ctx, &_Events_serviceDesc.Streams[0], c.cc, "/containerd.v1.services.events.Events/EventStream", opts...)
func (c *eventsClient) Stream(ctx context.Context, in *StreamEventsRequest, opts ...grpc.CallOption) (Events_StreamClient, error) {
stream, err := grpc.NewClientStream(ctx, &_Events_serviceDesc.Streams[0], c.cc, "/containerd.services.events.v1.Events/Stream", opts...)
if err != nil {
return nil, err
}
x := &eventsEventStreamClient{stream}
x := &eventsStreamClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
@ -87,16 +87,16 @@ func (c *eventsClient) EventStream(ctx context.Context, in *EventStreamRequest,
return x, nil
}
type Events_EventStreamClient interface {
type Events_StreamClient interface {
Recv() (*containerd_v1_types.Envelope, error)
grpc.ClientStream
}
type eventsEventStreamClient struct {
type eventsStreamClient struct {
grpc.ClientStream
}
func (x *eventsEventStreamClient) Recv() (*containerd_v1_types.Envelope, error) {
func (x *eventsStreamClient) Recv() (*containerd_v1_types.Envelope, error) {
m := new(containerd_v1_types.Envelope)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
@ -107,49 +107,49 @@ func (x *eventsEventStreamClient) Recv() (*containerd_v1_types.Envelope, error)
// Server API for Events service
type EventsServer interface {
EventStream(*EventStreamRequest, Events_EventStreamServer) error
Stream(*StreamEventsRequest, Events_StreamServer) error
}
func RegisterEventsServer(s *grpc.Server, srv EventsServer) {
s.RegisterService(&_Events_serviceDesc, srv)
}
func _Events_EventStream_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(EventStreamRequest)
func _Events_Stream_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(StreamEventsRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(EventsServer).EventStream(m, &eventsEventStreamServer{stream})
return srv.(EventsServer).Stream(m, &eventsStreamServer{stream})
}
type Events_EventStreamServer interface {
type Events_StreamServer interface {
Send(*containerd_v1_types.Envelope) error
grpc.ServerStream
}
type eventsEventStreamServer struct {
type eventsStreamServer struct {
grpc.ServerStream
}
func (x *eventsEventStreamServer) Send(m *containerd_v1_types.Envelope) error {
func (x *eventsStreamServer) Send(m *containerd_v1_types.Envelope) error {
return x.ServerStream.SendMsg(m)
}
var _Events_serviceDesc = grpc.ServiceDesc{
ServiceName: "containerd.v1.services.events.Events",
ServiceName: "containerd.services.events.v1.Events",
HandlerType: (*EventsServer)(nil),
Methods: []grpc.MethodDesc{},
Streams: []grpc.StreamDesc{
{
StreamName: "EventStream",
Handler: _Events_EventStream_Handler,
StreamName: "Stream",
Handler: _Events_Stream_Handler,
ServerStreams: true,
},
},
Metadata: "github.com/containerd/containerd/api/services/events/events.proto",
}
func (m *EventStreamRequest) Marshal() (dAtA []byte, err error) {
func (m *StreamEventsRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
@ -159,7 +159,7 @@ func (m *EventStreamRequest) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
func (m *EventStreamRequest) MarshalTo(dAtA []byte) (int, error) {
func (m *StreamEventsRequest) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
@ -194,7 +194,7 @@ func encodeVarintEvents(dAtA []byte, offset int, v uint64) int {
dAtA[offset] = uint8(v)
return offset + 1
}
func (m *EventStreamRequest) Size() (n int) {
func (m *StreamEventsRequest) Size() (n int) {
var l int
_ = l
return n
@ -213,11 +213,11 @@ func sovEvents(x uint64) (n int) {
func sozEvents(x uint64) (n int) {
return sovEvents(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *EventStreamRequest) String() string {
func (this *StreamEventsRequest) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&EventStreamRequest{`,
s := strings.Join([]string{`&StreamEventsRequest{`,
`}`,
}, "")
return s
@ -230,7 +230,7 @@ func valueToStringEvents(v interface{}) string {
pv := reflect.Indirect(rv).Interface()
return fmt.Sprintf("*%v", pv)
}
func (m *EventStreamRequest) Unmarshal(dAtA []byte) error {
func (m *StreamEventsRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@ -253,10 +253,10 @@ func (m *EventStreamRequest) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: EventStreamRequest: wiretype end group for non-group")
return fmt.Errorf("proto: StreamEventsRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: EventStreamRequest: illegal tag %d (wire type %d)", fieldNum, wire)
return fmt.Errorf("proto: StreamEventsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
default:
@ -390,17 +390,18 @@ func init() {
}
var fileDescriptorEvents = []byte{
// 192 bytes of a gzipped FileDescriptorProto
// 194 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x72, 0x4c, 0xcf, 0x2c, 0xc9,
0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xce, 0xcf, 0x2b, 0x49, 0xcc, 0xcc, 0x4b, 0x2d,
0x4a, 0x41, 0x66, 0x26, 0x16, 0x64, 0xea, 0x17, 0xa7, 0x16, 0x95, 0x65, 0x26, 0xa7, 0x16, 0xeb,
0xa7, 0x96, 0xa5, 0xe6, 0x95, 0xc0, 0x28, 0xbd, 0x82, 0xa2, 0xfc, 0x92, 0x7c, 0x21, 0x59, 0x84,
0x62, 0xbd, 0x32, 0x43, 0x3d, 0x98, 0x5a, 0x3d, 0x88, 0x22, 0x29, 0x1b, 0xa2, 0x6c, 0x28, 0xa9,
0x2c, 0x80, 0x19, 0x0f, 0x21, 0x21, 0x86, 0x2b, 0x89, 0x70, 0x09, 0xb9, 0x82, 0xb8, 0xc1, 0x25,
0x45, 0xa9, 0x89, 0xb9, 0x41, 0xa9, 0x85, 0xa5, 0xa9, 0xc5, 0x25, 0x46, 0xd9, 0x5c, 0x6c, 0x60,
0xd1, 0x62, 0xa1, 0x44, 0x2e, 0x6e, 0x24, 0x79, 0x21, 0x43, 0x3d, 0xbc, 0x8e, 0xd1, 0xc3, 0x34,
0x4b, 0x4a, 0x16, 0x4d, 0x0b, 0xd8, 0x25, 0x7a, 0xae, 0x79, 0x65, 0xa9, 0x39, 0xf9, 0x05, 0xa9,
0x06, 0x8c, 0x4e, 0x12, 0x27, 0x1e, 0xca, 0x31, 0xdc, 0x78, 0x28, 0xc7, 0xd0, 0xf0, 0x48, 0x8e,
0xf1, 0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18, 0x1f, 0x3c, 0x92, 0x63, 0x4c, 0x62, 0x03,
0xbb, 0xd1, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0xd7, 0x73, 0xbd, 0xf1, 0x45, 0x01, 0x00, 0x00,
0x62, 0x3d, 0x98, 0x42, 0x3d, 0xa8, 0x8a, 0x32, 0x43, 0x29, 0x1b, 0xa2, 0x6c, 0x28, 0xa9, 0x2c,
0x80, 0x19, 0x0f, 0x21, 0x21, 0x86, 0x2b, 0x89, 0x72, 0x09, 0x07, 0x97, 0x14, 0xa5, 0x26, 0xe6,
0xba, 0x82, 0x0d, 0x0c, 0x4a, 0x2d, 0x2c, 0x4d, 0x2d, 0x2e, 0x31, 0x4a, 0xe7, 0x62, 0x83, 0x08,
0x08, 0xc5, 0x72, 0xb1, 0x41, 0x14, 0x08, 0x19, 0xe9, 0xe1, 0x75, 0x88, 0x1e, 0x16, 0x73, 0xa4,
0x64, 0x91, 0xf5, 0x94, 0x19, 0xea, 0x81, 0x9d, 0xa1, 0xe7, 0x9a, 0x57, 0x96, 0x9a, 0x93, 0x5f,
0x90, 0x6a, 0xc0, 0xe8, 0x24, 0x71, 0xe2, 0xa1, 0x1c, 0xc3, 0x8d, 0x87, 0x72, 0x0c, 0x0d, 0x8f,
0xe4, 0x18, 0x4f, 0x3c, 0x92, 0x63, 0xbc, 0xf0, 0x48, 0x8e, 0xf1, 0xc1, 0x23, 0x39, 0xc6, 0x24,
0x36, 0xb0, 0x03, 0x8d, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x82, 0x06, 0x73, 0x76, 0x42, 0x01,
0x00, 0x00,
}

6
api/services/events/events.proto
View File

@ -1,11 +1,11 @@
syntax = "proto3";
package containerd.v1.services.events;
package containerd.services.events.v1;
import "github.com/containerd/containerd/api/types/event/event.proto";
service Events {
rpc EventStream(EventStreamRequest) returns (stream containerd.v1.types.Envelope);
rpc Stream(StreamEventsRequest) returns (stream containerd.v1.types.Envelope);
}
message EventStreamRequest {}
message StreamEventsRequest {}

1645
api/services/execution/execution.pb.go
View File

File diff suppressed because it is too large Load Diff

126
api/services/execution/execution.proto
View File

@ -1,6 +1,6 @@
syntax = "proto3";
package containerd.v1.services.execution;
package containerd.services.tasks.v1;
import "google/protobuf/empty.proto";
import "google/protobuf/any.proto";
@ -11,31 +11,47 @@ import "github.com/containerd/containerd/api/types/task/task.proto";
import "google/protobuf/timestamp.proto";
service Tasks {
rpc Create(CreateRequest) returns (CreateResponse);
rpc Start(StartRequest) returns (google.protobuf.Empty);
rpc Delete(DeleteRequest) returns (DeleteResponse);
// Create a task.
rpc Create(CreateTaskRequest) returns (CreateTaskResponse);
// Start a task.
rpc Start(StartTaskRequest) returns (google.protobuf.Empty);
// Delete a task and on disk state.
rpc Delete(DeleteTaskRequest) returns (DeleteResponse);
rpc DeleteProcess(DeleteProcessRequest) returns (DeleteResponse);
rpc Info(InfoRequest) returns (InfoResponse);
rpc List(ListRequest) returns (ListResponse);
rpc Get(GetTaskRequest) returns (GetTaskResponse);
rpc List(ListTasksRequest) returns (ListTasksResponse);
// Kill a task or process.
rpc Kill(KillRequest) returns (google.protobuf.Empty);
rpc Events(EventsRequest) returns (stream containerd.v1.types.Event);
rpc Exec(ExecRequest) returns (ExecResponse);
rpc Pty(PtyRequest) returns (google.protobuf.Empty);
rpc CloseStdin(CloseStdinRequest) returns (google.protobuf.Empty);
rpc Pause(PauseRequest) returns (google.protobuf.Empty);
rpc Resume(ResumeRequest) returns (google.protobuf.Empty);
rpc Processes(ProcessesRequest) returns (ProcessesResponse);
rpc Checkpoint(CheckpointRequest) returns (CheckpointResponse);
rpc Exec(ExecProcessRequest) returns (ExecProcessResponse);
rpc ResizePty(ResizePtyRequest) returns (google.protobuf.Empty);
rpc CloseIO(CloseIORequest) returns (google.protobuf.Empty);
rpc Pause(PauseTaskRequest) returns (google.protobuf.Empty);
rpc Resume(ResumeTaskRequest) returns (google.protobuf.Empty);
rpc ListProcesses(ListProcessesRequest) returns (ListProcessesResponse);
rpc Checkpoint(CheckpointTaskRequest) returns (CheckpointTaskResponse);
}
message CreateRequest {
message CreateTaskRequest {
// NOTE: reserve field 1 for task id.
// ContainerID specifies the container to use for creating this task.
//
// The spec from the provided container id will be used to create the
// task associated with this container. Only one task can be run at a time
// per container.
//
// This should be created using the Containers service.
string container_id = 2;
// RootFS provides the pre-chroot mounts to perform in the shim before
@ -46,15 +62,15 @@ message CreateRequest {
// the container object.
repeated containerd.v1.types.Mount rootfs = 3;
string stdin = 5;
string stdout = 6;
string stderr = 7;
bool terminal = 8;
string stdin = 4;
string stdout = 5;
string stderr = 6;
bool terminal = 7;
types.Descriptor checkpoint = 9;
containerd.v1.types.Descriptor checkpoint = 8;
}
message CreateResponse {
message CreateTaskResponse {
// TODO(stevvooe): We no longer have an id for a task since they are bound
// to a single container. Although, we should represent each new task with
// an ID so one can differentiate between each instance of a container
@ -68,18 +84,19 @@ message CreateResponse {
uint32 pid = 3;
}
message StartRequest {
message StartTaskRequest {
string container_id = 1;
}
message DeleteRequest {
message DeleteTaskRequest {
string container_id = 1;
}
message DeleteResponse {
string container_id = 1;
uint32 exit_status = 2;
google.protobuf.Timestamp exited_at = 3 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
uint32 pid = 2;
uint32 exit_status = 3;
google.protobuf.Timestamp exited_at = 4 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
}
message DeleteProcessRequest {
@ -87,18 +104,19 @@ message DeleteProcessRequest {
uint32 pid = 2;
}
message InfoRequest {
message GetTaskRequest {
string container_id = 1;
}
message InfoResponse {
types.Task task = 1;
message GetTaskResponse {
containerd.v1.types.Task task = 1;
}
message ListRequest {
message ListTasksRequest {
string filter = 1;
}
message ListResponse {
message ListTasksResponse {
repeated containerd.v1.types.Task tasks = 1;
}
@ -111,16 +129,14 @@ message KillRequest {
}
}
message EventsRequest {
}
message ExecRequest {
message ExecProcessRequest {
// ContainerID specifies the container in which to exec the process.
string container_id = 1;
bool terminal = 2;
string stdin = 3;
string stdout = 4;
string stderr = 5;
string stdin = 2;
string stdout = 3;
string stderr = 4;
bool terminal = 5;
// Spec for starting a process in the target container.
//
@ -128,49 +144,45 @@ message ExecRequest {
google.protobuf.Any spec = 6;
}
message ExecResponse {
message ExecProcessResponse {
uint32 pid = 1;
}
message PtyRequest {
message ResizePtyRequest {
string container_id = 1;
uint32 pid = 2;
uint32 width = 3;
uint32 height = 4;
}
message CloseStdinRequest {
message CloseIORequest {
string container_id = 1;
uint32 pid = 2;
bool stdin = 3;
}
message PauseRequest {
message PauseTaskRequest {
string container_id = 1;
}
message ResumeRequest {
message ResumeTaskRequest {
string container_id = 1;
}
message ProcessesRequest {
message ListProcessesRequest {
string container_id = 1;
}
message ProcessesResponse{
message ListProcessesResponse{
repeated containerd.v1.types.Process processes = 1;
}
message CheckpointRequest {
message CheckpointTaskRequest {
string container_id = 1;
bool allow_tcp = 2;
bool allow_unix_sockets = 3;
bool allow_terminal = 4;
bool file_locks = 5;
repeated string empty_namespaces = 6;
string parent_checkpoint = 7 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false];
bool exit = 8;
string parent_checkpoint = 2 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false];
map<string, string> options = 3;
}
message CheckpointResponse {
repeated types.Descriptor descriptors = 1;
message CheckpointTaskResponse {
repeated containerd.v1.types.Descriptor descriptors = 1;
}

647
api/services/images/images.pb.go
View File

File diff suppressed because it is too large Load Diff

49
api/services/images/images.proto
View File

@ -1,10 +1,9 @@
syntax = "proto3";
package containerd.v1;
package containerd.services.images.v1;
import "gogoproto/gogo.proto";
import "google/protobuf/empty.proto";
import "github.com/containerd/containerd/api/types/mount/mount.proto";
import "github.com/containerd/containerd/api/types/descriptor/descriptor.proto";
// Images is a service that allows one to register images with containerd.
@ -20,59 +19,49 @@ import "github.com/containerd/containerd/api/types/descriptor/descriptor.proto";
// As such, this can really be considered a "metadata service".
service Images {
// Get returns an image by name.
rpc Get(GetRequest) returns (GetResponse);
rpc Get(GetImageRequest) returns (GetImageResponse);
// List returns a list of all images known to containerd.
rpc List(ListRequest) returns (ListResponse);
rpc List(ListImagesRequest) returns (ListImagesResponse);
// Put assigns the name to a given target image based on the provided
// Update assigns the name to a given target image based on the provided
// image.
rpc Put(PutRequest) returns (google.protobuf.Empty);
rpc Update(UpdateImageRequest) returns (UpdateImageResponse);
// Delete deletes the image by name.
rpc Delete(DeleteRequest) returns (google.protobuf.Empty);
rpc Delete(DeleteImageRequest) returns (google.protobuf.Empty);
}
message Image {
string name = 1;
string labels = 2;
types.Descriptor target = 3 [(gogoproto.nullable) = false];
map<string, string> labels = 2;
containerd.v1.types.Descriptor target = 3 [(gogoproto.nullable) = false];
}
message GetRequest {
message GetImageRequest {
string name = 1;
// TODO(stevvooe): Consider that we may want to have multiple images under
// the same name or multiple names for the same image. This mapping could
// be truly many to many but we'll need a way to identify an entry.
//
// For now, we consider it unique but an intermediary index could be
// created to allow for a dispatch of images.
}
message GetResponse {
message GetImageResponse {
Image image = 1;
}
message PutRequest {
message UpdateImageRequest {
Image image = 1 [(gogoproto.nullable) = false];
}
message ListRequest {
// TODO(stevvooe): empty for now, need to ad filtration
// Some common use cases we might consider:
//
// 1. Select by multiple names.
// 2. Select by platform.
// 3. Select by annotations.
message UpdateImageResponse {
Image image = 1 [(gogoproto.nullable) = false];
}
message ListResponse {
message ListImagesRequest {
string filter = 1;
}
message ListImagesResponse {
repeated Image images = 1 [(gogoproto.nullable) = false];
// TODO(stevvooe): Add pagination.
}
message DeleteRequest {
message DeleteImageRequest {
string name = 1;
}

111
api/services/namespaces/namespace.pb.go
View File

@ -152,16 +152,16 @@ func (*DeleteNamespaceRequest) ProtoMessage() {}
func (*DeleteNamespaceRequest) Descriptor() ([]byte, []int) { return fileDescriptorNamespace, []int{9} }
func init() {
proto.RegisterType((*Namespace)(nil), "containerd.v1.namespaces.Namespace")
proto.RegisterType((*GetNamespaceRequest)(nil), "containerd.v1.namespaces.GetNamespaceRequest")
proto.RegisterType((*GetNamespaceResponse)(nil), "containerd.v1.namespaces.GetNamespaceResponse")
proto.RegisterType((*ListNamespacesRequest)(nil), "containerd.v1.namespaces.ListNamespacesRequest")
proto.RegisterType((*ListNamespacesResponse)(nil), "containerd.v1.namespaces.ListNamespacesResponse")
proto.RegisterType((*CreateNamespaceRequest)(nil), "containerd.v1.namespaces.CreateNamespaceRequest")
proto.RegisterType((*CreateNamespaceResponse)(nil), "containerd.v1.namespaces.CreateNamespaceResponse")
proto.RegisterType((*UpdateNamespaceRequest)(nil), "containerd.v1.namespaces.UpdateNamespaceRequest")
proto.RegisterType((*UpdateNamespaceResponse)(nil), "containerd.v1.namespaces.UpdateNamespaceResponse")
proto.RegisterType((*DeleteNamespaceRequest)(nil), "containerd.v1.namespaces.DeleteNamespaceRequest")
proto.RegisterType((*Namespace)(nil), "containerd.services.namespaces.v1.Namespace")
proto.RegisterType((*GetNamespaceRequest)(nil), "containerd.services.namespaces.v1.GetNamespaceRequest")
proto.RegisterType((*GetNamespaceResponse)(nil), "containerd.services.namespaces.v1.GetNamespaceResponse")
proto.RegisterType((*ListNamespacesRequest)(nil), "containerd.services.namespaces.v1.ListNamespacesRequest")
proto.RegisterType((*ListNamespacesResponse)(nil), "containerd.services.namespaces.v1.ListNamespacesResponse")
proto.RegisterType((*CreateNamespaceRequest)(nil), "containerd.services.namespaces.v1.CreateNamespaceRequest")
proto.RegisterType((*CreateNamespaceResponse)(nil), "containerd.services.namespaces.v1.CreateNamespaceResponse")
proto.RegisterType((*UpdateNamespaceRequest)(nil), "containerd.services.namespaces.v1.UpdateNamespaceRequest")
proto.RegisterType((*UpdateNamespaceResponse)(nil), "containerd.services.namespaces.v1.UpdateNamespaceResponse")
proto.RegisterType((*DeleteNamespaceRequest)(nil), "containerd.services.namespaces.v1.DeleteNamespaceRequest")
}
// Reference imports to suppress errors if they are not otherwise used.
@ -192,7 +192,7 @@ func NewNamespacesClient(cc *grpc.ClientConn) NamespacesClient {
func (c *namespacesClient) Get(ctx context.Context, in *GetNamespaceRequest, opts ...grpc.CallOption) (*GetNamespaceResponse, error) {
out := new(GetNamespaceResponse)
err := grpc.Invoke(ctx, "/containerd.v1.namespaces.Namespaces/Get", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/containerd.services.namespaces.v1.Namespaces/Get", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
@ -201,7 +201,7 @@ func (c *namespacesClient) Get(ctx context.Context, in *GetNamespaceRequest, opt
func (c *namespacesClient) List(ctx context.Context, in *ListNamespacesRequest, opts ...grpc.CallOption) (*ListNamespacesResponse, error) {
out := new(ListNamespacesResponse)
err := grpc.Invoke(ctx, "/containerd.v1.namespaces.Namespaces/List", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/containerd.services.namespaces.v1.Namespaces/List", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
@ -210,7 +210,7 @@ func (c *namespacesClient) List(ctx context.Context, in *ListNamespacesRequest,
func (c *namespacesClient) Create(ctx context.Context, in *CreateNamespaceRequest, opts ...grpc.CallOption) (*CreateNamespaceResponse, error) {
out := new(CreateNamespaceResponse)
err := grpc.Invoke(ctx, "/containerd.v1.namespaces.Namespaces/Create", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/containerd.services.namespaces.v1.Namespaces/Create", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
@ -219,7 +219,7 @@ func (c *namespacesClient) Create(ctx context.Context, in *CreateNamespaceReques
func (c *namespacesClient) Update(ctx context.Context, in *UpdateNamespaceRequest, opts ...grpc.CallOption) (*UpdateNamespaceResponse, error) {
out := new(UpdateNamespaceResponse)
err := grpc.Invoke(ctx, "/containerd.v1.namespaces.Namespaces/Update", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/containerd.services.namespaces.v1.Namespaces/Update", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
@ -228,7 +228,7 @@ func (c *namespacesClient) Update(ctx context.Context, in *UpdateNamespaceReques
func (c *namespacesClient) Delete(ctx context.Context, in *DeleteNamespaceRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) {
out := new(google_protobuf1.Empty)
err := grpc.Invoke(ctx, "/containerd.v1.namespaces.Namespaces/Delete", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/containerd.services.namespaces.v1.Namespaces/Delete", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
@ -259,7 +259,7 @@ func _Namespaces_Get_Handler(srv interface{}, ctx context.Context, dec func(inte
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.v1.namespaces.Namespaces/Get",
FullMethod: "/containerd.services.namespaces.v1.Namespaces/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(NamespacesServer).Get(ctx, req.(*GetNamespaceRequest))
@ -277,7 +277,7 @@ func _Namespaces_List_Handler(srv interface{}, ctx context.Context, dec func(int
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.v1.namespaces.Namespaces/List",
FullMethod: "/containerd.services.namespaces.v1.Namespaces/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(NamespacesServer).List(ctx, req.(*ListNamespacesRequest))
@ -295,7 +295,7 @@ func _Namespaces_Create_Handler(srv interface{}, ctx context.Context, dec func(i
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.v1.namespaces.Namespaces/Create",
FullMethod: "/containerd.services.namespaces.v1.Namespaces/Create",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(NamespacesServer).Create(ctx, req.(*CreateNamespaceRequest))
@ -313,7 +313,7 @@ func _Namespaces_Update_Handler(srv interface{}, ctx context.Context, dec func(i
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.v1.namespaces.Namespaces/Update",
FullMethod: "/containerd.services.namespaces.v1.Namespaces/Update",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(NamespacesServer).Update(ctx, req.(*UpdateNamespaceRequest))
@ -331,7 +331,7 @@ func _Namespaces_Delete_Handler(srv interface{}, ctx context.Context, dec func(i
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.v1.namespaces.Namespaces/Delete",
FullMethod: "/containerd.services.namespaces.v1.Namespaces/Delete",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(NamespacesServer).Delete(ctx, req.(*DeleteNamespaceRequest))
@ -340,7 +340,7 @@ func _Namespaces_Delete_Handler(srv interface{}, ctx context.Context, dec func(i
}
var _Namespaces_serviceDesc = grpc.ServiceDesc{
ServiceName: "containerd.v1.namespaces.Namespaces",
ServiceName: "containerd.services.namespaces.v1.Namespaces",
HandlerType: (*NamespacesServer)(nil),
Methods: []grpc.MethodDesc{
{
@ -1971,38 +1971,39 @@ func init() {
}
var fileDescriptorNamespace = []byte{
// 528 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x54, 0xbd, 0x8e, 0xd3, 0x4c,
0x14, 0xcd, 0x24, 0xf9, 0x2c, 0xe5, 0xba, 0xf9, 0x34, 0x04, 0x63, 0x19, 0xc9, 0x44, 0xa6, 0x59,
0x24, 0x18, 0xb3, 0xa1, 0xe1, 0xa7, 0x5b, 0x58, 0x02, 0xd2, 0x42, 0x61, 0x89, 0x7a, 0x35, 0x4e,
0x26, 0xc6, 0x8a, 0xff, 0xf0, 0x8c, 0x23, 0xa5, 0xe3, 0x0d, 0x78, 0x03, 0x1a, 0x5e, 0x26, 0x25,
0x25, 0x15, 0x62, 0xf3, 0x24, 0xc8, 0x63, 0x27, 0xce, 0x6e, 0x1c, 0x2b, 0x2b, 0x85, 0xee, 0x8e,
0x7d, 0x8e, 0xcf, 0xb9, 0xd7, 0xe7, 0x0e, 0xbc, 0xf3, 0x7c, 0xf1, 0x39, 0x73, 0xc9, 0x38, 0x0e,
0xed, 0x71, 0x1c, 0x09, 0xea, 0x47, 0x2c, 0x9d, 0x6c, 0x97, 0x34, 0xf1, 0x6d, 0xce, 0xd2, 0xb9,
0x3f, 0x66, 0xdc, 0x8e, 0x68, 0xc8, 0x78, 0x42, 0xaf, 0x95, 0x24, 0x49, 0x63, 0x11, 0x63, 0xbd,
0xe2, 0x90, 0xf9, 0x29, 0xa9, 0x90, 0x46, 0xdf, 0x8b, 0xbd, 0x58, 0x82, 0xec, 0xbc, 0x2a, 0xf0,
0xc6, 0x7d, 0x2f, 0x8e, 0xbd, 0x80, 0xd9, 0xf2, 0xe4, 0x66, 0x53, 0x9b, 0x85, 0x89, 0x58, 0x94,
0x2f, 0x07, 0x37, 0x5f, 0x4e, 0x7d, 0x16, 0x4c, 0x2e, 0x43, 0xca, 0x67, 0x05, 0xc2, 0xfa, 0x81,
0xa0, 0xf7, 0x71, 0xad, 0x81, 0x31, 0x74, 0x73, 0x41, 0x1d, 0x0d, 0xd0, 0x49, 0xcf, 0x91, 0x35,
0x1e, 0x81, 0x12, 0x50, 0x97, 0x05, 0x5c, 0x6f, 0x0f, 0x3a, 0x27, 0xea, 0xd0, 0x26, 0xfb, 0x1c,
0x92, 0xcd, 0x87, 0xc8, 0x85, 0x64, 0x9c, 0x47, 0x22, 0x5d, 0x38, 0x25, 0xdd, 0x78, 0x01, 0xea,
0xd6, 0x63, 0xfc, 0x3f, 0x74, 0x66, 0x6c, 0x51, 0x4a, 0xe5, 0x25, 0xee, 0xc3, 0x7f, 0x73, 0x1a,
0x64, 0x4c, 0x6f, 0xcb, 0x67, 0xc5, 0xe1, 0x65, 0xfb, 0x39, 0xb2, 0x1e, 0xc1, 0x9d, 0x11, 0x13,
0x9b, 0xcf, 0x3b, 0xec, 0x4b, 0xc6, 0xb8, 0xa8, 0xb3, 0x6b, 0x5d, 0x42, 0xff, 0x3a, 0x94, 0x27,
0x71, 0xc4, 0xf3, 0x36, 0x7a, 0x1b, 0xa7, 0x92, 0xa0, 0x0e, 0x1f, 0x1e, 0xd0, 0xc9, 0x59, 0x77,
0xf9, 0xfb, 0x41, 0xcb, 0xa9, 0xb8, 0x96, 0x0d, 0x77, 0x2f, 0x7c, 0x5e, 0x29, 0xf0, 0xb5, 0x1b,
0x0d, 0x94, 0xa9, 0x1f, 0x08, 0x96, 0x96, 0x7e, 0xca, 0x93, 0x35, 0x06, 0xed, 0x26, 0xa1, 0xf4,
0xf4, 0x1e, 0xa0, 0xd2, 0xd4, 0x91, 0x1c, 0xef, 0x2d, 0x4c, 0x6d, 0x91, 0x2d, 0x0a, 0xda, 0xeb,
0x94, 0x51, 0xc1, 0x76, 0x86, 0x74, 0xb4, 0xc6, 0x5d, 0xb8, 0xb7, 0x23, 0x71, 0xec, 0xe1, 0x7e,
0x47, 0xa0, 0x7d, 0x4a, 0x26, 0xff, 0xb2, 0x0f, 0xfc, 0x0a, 0xd4, 0x4c, 0x4a, 0xc8, 0x3d, 0x90,
0x61, 0x53, 0x87, 0x06, 0x29, 0x56, 0x85, 0xac, 0x57, 0x85, 0xbc, 0xcd, 0x57, 0xe5, 0x03, 0xe5,
0x33, 0x07, 0x0a, 0x78, 0x5e, 0xe7, 0x43, 0xd8, 0xf1, 0x77, 0xec, 0x21, 0x3c, 0x06, 0xed, 0x0d,
0x0b, 0x58, 0xcd, 0x0c, 0x6a, 0x02, 0x3f, 0xfc, 0xd6, 0x05, 0xa8, 0xb2, 0x85, 0x27, 0xd0, 0x19,
0x31, 0x81, 0x9f, 0xec, 0x57, 0xae, 0xd9, 0x24, 0x83, 0x1c, 0x0a, 0x2f, 0x7b, 0xf5, 0xa1, 0x9b,
0x67, 0x1a, 0x37, 0x5c, 0x06, 0xb5, 0x4b, 0x62, 0x3c, 0x3d, 0x9c, 0x50, 0x4a, 0x85, 0xa0, 0x14,
0xb1, 0xc3, 0x0d, 0xdc, 0xfa, 0xec, 0x1b, 0xa7, 0xb7, 0x60, 0x54, 0x72, 0xc5, 0x0f, 0x6e, 0x92,
0xab, 0x8f, 0x68, 0x93, 0xdc, 0xbe, 0xd0, 0x38, 0xa0, 0x14, 0xff, 0xba, 0x49, 0xae, 0x3e, 0x0d,
0x86, 0xb6, 0x93, 0xd9, 0xf3, 0xfc, 0xee, 0x3f, 0xd3, 0x97, 0x57, 0x66, 0xeb, 0xd7, 0x95, 0xd9,
0xfa, 0xba, 0x32, 0xd1, 0x72, 0x65, 0xa2, 0x9f, 0x2b, 0x13, 0xfd, 0x59, 0x99, 0xc8, 0x55, 0x24,
0xf2, 0xd9, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf0, 0x2e, 0xc3, 0x29, 0xaf, 0x06, 0x00, 0x00,
// 536 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x55, 0xc1, 0x6e, 0xd3, 0x40,
0x10, 0xcd, 0x26, 0x21, 0x52, 0xc6, 0x17, 0xb4, 0x04, 0x63, 0x19, 0xc9, 0x04, 0x9f, 0x8a, 0x54,
0xad, 0x45, 0x90, 0xa0, 0x2d, 0xb7, 0x42, 0x29, 0x87, 0x82, 0x90, 0x25, 0x4e, 0x1c, 0x90, 0x93,
0x4c, 0x5c, 0x13, 0xc7, 0x36, 0xde, 0x75, 0xa4, 0x88, 0x03, 0xfc, 0x0d, 0x17, 0x3e, 0x24, 0x47,
0x8e, 0x9c, 0x50, 0x9b, 0x2f, 0x41, 0x5e, 0x3b, 0x71, 0xda, 0x18, 0xe1, 0x46, 0xb4, 0xb7, 0x59,
0xef, 0xcc, 0xbc, 0xb7, 0x4f, 0xef, 0x25, 0xf0, 0xda, 0xf5, 0xc4, 0x69, 0xd2, 0x67, 0x83, 0x70,
0x62, 0x0d, 0xc2, 0x40, 0x38, 0x5e, 0x80, 0xf1, 0x70, 0xbd, 0x74, 0x22, 0xcf, 0xe2, 0x18, 0x4f,
0xbd, 0x01, 0x72, 0x2b, 0x70, 0x26, 0xc8, 0x23, 0xe7, 0x42, 0xc9, 0xa2, 0x38, 0x14, 0x21, 0x7d,
0x58, 0xcc, 0xb0, 0x65, 0x3f, 0x2b, 0xfa, 0xd9, 0xf4, 0xb1, 0xde, 0x71, 0x43, 0x37, 0x94, 0xdd,
0x56, 0x5a, 0x65, 0x83, 0xfa, 0x7d, 0x37, 0x0c, 0x5d, 0x1f, 0x2d, 0x79, 0xea, 0x27, 0x23, 0x0b,
0x27, 0x91, 0x98, 0xe5, 0x97, 0xdd, 0xcb, 0x97, 0x23, 0x0f, 0xfd, 0xe1, 0xc7, 0x89, 0xc3, 0xc7,
0x59, 0x87, 0xf9, 0x83, 0x40, 0xfb, 0xed, 0x12, 0x86, 0x52, 0x68, 0xa6, 0x98, 0x1a, 0xe9, 0x92,
0x9d, 0xb6, 0x2d, 0x6b, 0xfa, 0x0e, 0x5a, 0xbe, 0xd3, 0x47, 0x9f, 0x6b, 0xf5, 0x6e, 0x63, 0x47,
0xe9, 0xed, 0xb1, 0x7f, 0x52, 0x65, 0xab, 0x8d, 0xec, 0x44, 0x8e, 0x1e, 0x05, 0x22, 0x9e, 0xd9,
0xf9, 0x1e, 0x7d, 0x1f, 0x94, 0xb5, 0xcf, 0xf4, 0x36, 0x34, 0xc6, 0x38, 0xcb, 0x31, 0xd3, 0x92,
0x76, 0xe0, 0xd6, 0xd4, 0xf1, 0x13, 0xd4, 0xea, 0xf2, 0x5b, 0x76, 0x38, 0xa8, 0xef, 0x11, 0xf3,
0x11, 0xdc, 0x39, 0x46, 0xb1, 0x5a, 0x6f, 0xe3, 0xe7, 0x04, 0xb9, 0x28, 0xe3, 0x6d, 0x9e, 0x42,
0xe7, 0x62, 0x2b, 0x8f, 0xc2, 0x80, 0xa7, 0xef, 0x69, 0xaf, 0xc8, 0xca, 0x01, 0xa5, 0xb7, 0x7b,
0x95, 0x27, 0x1d, 0x36, 0xe7, 0xbf, 0x1f, 0xd4, 0xec, 0x62, 0x89, 0x69, 0xc1, 0xdd, 0x13, 0x8f,
0x17, 0x50, 0x7c, 0x49, 0x4b, 0x85, 0xd6, 0xc8, 0xf3, 0x05, 0xc6, 0x39, 0xb1, 0xfc, 0x64, 0xfa,
0xa0, 0x5e, 0x1e, 0xc8, 0xc9, 0xd9, 0x00, 0x05, 0xac, 0x46, 0xa4, 0xe0, 0xdb, 0xb0, 0x5b, 0xdb,
0x62, 0x7e, 0x02, 0xf5, 0x45, 0x8c, 0x8e, 0xc0, 0x0d, 0xd9, 0xfe, 0xbf, 0x14, 0x63, 0xb8, 0xb7,
0x81, 0x75, 0x6d, 0xba, 0x7f, 0x27, 0xa0, 0xbe, 0x8f, 0x86, 0x37, 0xf2, 0x32, 0xfa, 0x1c, 0x94,
0x44, 0x62, 0xc9, 0xf4, 0x48, 0x67, 0x2a, 0x3d, 0x9d, 0x65, 0x01, 0x63, 0xcb, 0x80, 0xb1, 0x57,
0x69, 0xc0, 0xde, 0x38, 0x7c, 0x6c, 0x43, 0xd6, 0x9e, 0xd6, 0xa9, 0x2c, 0x1b, 0x44, 0xaf, 0x4d,
0x96, 0x5d, 0x50, 0x5f, 0xa2, 0x8f, 0x25, 0xaa, 0x94, 0xc4, 0xa4, 0x77, 0xd6, 0x04, 0x28, 0x8c,
0x48, 0xa7, 0xd0, 0x38, 0x46, 0x41, 0x9f, 0x56, 0xa0, 0x50, 0x12, 0x44, 0xfd, 0xd9, 0x95, 0xe7,
0x72, 0x19, 0xbe, 0x40, 0x33, 0x8d, 0x04, 0xad, 0xf2, 0xeb, 0x52, 0x1a, 0x36, 0x7d, 0x7f, 0x8b,
0xc9, 0x1c, 0xfc, 0x2b, 0xb4, 0x32, 0xd7, 0xd2, 0x2a, 0x4b, 0xca, 0xc3, 0xa4, 0x1f, 0x6c, 0x33,
0x5a, 0x10, 0xc8, 0xfc, 0x51, 0x89, 0x40, 0xb9, 0xe7, 0x2b, 0x11, 0xf8, 0x9b, 0x0b, 0x3f, 0x40,
0x2b, 0xf3, 0x4c, 0x25, 0x02, 0xe5, 0xf6, 0xd2, 0xd5, 0x8d, 0x34, 0x1c, 0xa5, 0xff, 0x45, 0x87,
0xda, 0xfc, 0xdc, 0xa8, 0xfd, 0x3a, 0x37, 0x6a, 0xdf, 0x16, 0x06, 0x99, 0x2f, 0x0c, 0xf2, 0x73,
0x61, 0x90, 0xb3, 0x85, 0x41, 0xfa, 0x2d, 0xd9, 0xf9, 0xe4, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff,
0x88, 0x7f, 0xdb, 0x9f, 0x48, 0x07, 0x00, 0x00,
}

4
api/services/namespaces/namespace.proto
View File

@ -1,6 +1,6 @@
syntax = "proto3";
package containerd.v1.namespaces;
package containerd.services.namespaces.v1;
import "gogoproto/gogo.proto";
import "google/protobuf/empty.proto";
@ -44,7 +44,7 @@ message GetNamespaceResponse {
}
message ListNamespacesRequest {
string filter = 1; // TODO(stevvooe): Define a filtering syntax to make these queries.
string filter = 1;
}
message ListNamespacesResponse {

635
api/services/shim/shim.pb.go
View File

@ -54,6 +54,7 @@ import github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
import strings "strings"
import reflect "reflect"
import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
import io "io"
@ -110,8 +111,9 @@ func (*DeleteRequest) ProtoMessage() {}
func (*DeleteRequest) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{3} }
type DeleteResponse struct {
ExitStatus uint32 `protobuf:"varint,1,opt,name=exit_status,json=exitStatus,proto3" json:"exit_status,omitempty"`
ExitedAt time.Time `protobuf:"bytes,2,opt,name=exited_at,json=exitedAt,stdtime" json:"exited_at"`
Pid uint32 `protobuf:"varint,1,opt,name=pid,proto3" json:"pid,omitempty"`
ExitStatus uint32 `protobuf:"varint,2,opt,name=exit_status,json=exitStatus,proto3" json:"exit_status,omitempty"`
ExitedAt time.Time `protobuf:"bytes,3,opt,name=exited_at,json=exitedAt,stdtime" json:"exited_at"`
}
func (m *DeleteResponse) Reset() { *m = DeleteResponse{} }
@ -252,13 +254,8 @@ func (*ProcessesResponse) ProtoMessage() {}
func (*ProcessesResponse) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{19} }
type CheckpointRequest struct {
Exit bool `protobuf:"varint,1,opt,name=exit,proto3" json:"exit,omitempty"`
AllowTcp bool `protobuf:"varint,2,opt,name=allow_tcp,json=allowTcp,proto3" json:"allow_tcp,omitempty"`
AllowUnixSockets bool `protobuf:"varint,3,opt,name=allow_unix_sockets,json=allowUnixSockets,proto3" json:"allow_unix_sockets,omitempty"`
AllowTerminal bool `protobuf:"varint,4,opt,name=allow_terminal,json=allowTerminal,proto3" json:"allow_terminal,omitempty"`
FileLocks bool `protobuf:"varint,5,opt,name=file_locks,json=fileLocks,proto3" json:"file_locks,omitempty"`
EmptyNamespaces []string `protobuf:"bytes,6,rep,name=empty_namespaces,json=emptyNamespaces" json:"empty_namespaces,omitempty"`
CheckpointPath string `protobuf:"bytes,7,opt,name=checkpoint_path,json=checkpointPath,proto3" json:"checkpoint_path,omitempty"`
Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
Options map[string]string `protobuf:"bytes,2,rep,name=options" json:"options,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (m *CheckpointRequest) Reset() { *m = CheckpointRequest{} }
@ -266,27 +263,27 @@ func (*CheckpointRequest) ProtoMessage() {}
func (*CheckpointRequest) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{20} }
func init() {
proto.RegisterType((*CreateRequest)(nil), "containerd.v1.services.shim.CreateRequest")
proto.RegisterType((*CreateResponse)(nil), "containerd.v1.services.shim.CreateResponse")
proto.RegisterType((*StartRequest)(nil), "containerd.v1.services.shim.StartRequest")
proto.RegisterType((*DeleteRequest)(nil), "containerd.v1.services.shim.DeleteRequest")
proto.RegisterType((*DeleteResponse)(nil), "containerd.v1.services.shim.DeleteResponse")
proto.RegisterType((*DeleteProcessRequest)(nil), "containerd.v1.services.shim.DeleteProcessRequest")
proto.RegisterType((*ExecRequest)(nil), "containerd.v1.services.shim.ExecRequest")
proto.RegisterType((*Rlimit)(nil), "containerd.v1.services.shim.Rlimit")
proto.RegisterType((*ExecResponse)(nil), "containerd.v1.services.shim.ExecResponse")
proto.RegisterType((*PtyRequest)(nil), "containerd.v1.services.shim.PtyRequest")
proto.RegisterType((*EventsRequest)(nil), "containerd.v1.services.shim.EventsRequest")
proto.RegisterType((*StateRequest)(nil), "containerd.v1.services.shim.StateRequest")
proto.RegisterType((*StateResponse)(nil), "containerd.v1.services.shim.StateResponse")
proto.RegisterType((*PauseRequest)(nil), "containerd.v1.services.shim.PauseRequest")
proto.RegisterType((*ResumeRequest)(nil), "containerd.v1.services.shim.ResumeRequest")
proto.RegisterType((*ExitRequest)(nil), "containerd.v1.services.shim.ExitRequest")
proto.RegisterType((*KillRequest)(nil), "containerd.v1.services.shim.KillRequest")
proto.RegisterType((*CloseStdinRequest)(nil), "containerd.v1.services.shim.CloseStdinRequest")
proto.RegisterType((*ProcessesRequest)(nil), "containerd.v1.services.shim.ProcessesRequest")
proto.RegisterType((*ProcessesResponse)(nil), "containerd.v1.services.shim.ProcessesResponse")
proto.RegisterType((*CheckpointRequest)(nil), "containerd.v1.services.shim.CheckpointRequest")
proto.RegisterType((*CreateRequest)(nil), "containerd.runtime.linux.shim.v1.CreateRequest")
proto.RegisterType((*CreateResponse)(nil), "containerd.runtime.linux.shim.v1.CreateResponse")
proto.RegisterType((*StartRequest)(nil), "containerd.runtime.linux.shim.v1.StartRequest")
proto.RegisterType((*DeleteRequest)(nil), "containerd.runtime.linux.shim.v1.DeleteRequest")
proto.RegisterType((*DeleteResponse)(nil), "containerd.runtime.linux.shim.v1.DeleteResponse")
proto.RegisterType((*DeleteProcessRequest)(nil), "containerd.runtime.linux.shim.v1.DeleteProcessRequest")
proto.RegisterType((*ExecRequest)(nil), "containerd.runtime.linux.shim.v1.ExecRequest")
proto.RegisterType((*Rlimit)(nil), "containerd.runtime.linux.shim.v1.Rlimit")
proto.RegisterType((*ExecResponse)(nil), "containerd.runtime.linux.shim.v1.ExecResponse")
proto.RegisterType((*PtyRequest)(nil), "containerd.runtime.linux.shim.v1.PtyRequest")
proto.RegisterType((*EventsRequest)(nil), "containerd.runtime.linux.shim.v1.EventsRequest")
proto.RegisterType((*StateRequest)(nil), "containerd.runtime.linux.shim.v1.StateRequest")
proto.RegisterType((*StateResponse)(nil), "containerd.runtime.linux.shim.v1.StateResponse")
proto.RegisterType((*PauseRequest)(nil), "containerd.runtime.linux.shim.v1.PauseRequest")
proto.RegisterType((*ResumeRequest)(nil), "containerd.runtime.linux.shim.v1.ResumeRequest")
proto.RegisterType((*ExitRequest)(nil), "containerd.runtime.linux.shim.v1.ExitRequest")
proto.RegisterType((*KillRequest)(nil), "containerd.runtime.linux.shim.v1.KillRequest")
proto.RegisterType((*CloseStdinRequest)(nil), "containerd.runtime.linux.shim.v1.CloseStdinRequest")
proto.RegisterType((*ProcessesRequest)(nil), "containerd.runtime.linux.shim.v1.ProcessesRequest")
proto.RegisterType((*ProcessesResponse)(nil), "containerd.runtime.linux.shim.v1.ProcessesResponse")
proto.RegisterType((*CheckpointRequest)(nil), "containerd.runtime.linux.shim.v1.CheckpointRequest")
}
// Reference imports to suppress errors if they are not otherwise used.
@ -327,7 +324,7 @@ func NewShimClient(cc *grpc.ClientConn) ShimClient {
func (c *shimClient) Create(ctx context.Context, in *CreateRequest, opts ...grpc.CallOption) (*CreateResponse, error) {
out := new(CreateResponse)
err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/Create", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/Create", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
@ -336,7 +333,7 @@ func (c *shimClient) Create(ctx context.Context, in *CreateRequest, opts ...grpc
func (c *shimClient) Start(ctx context.Context, in *StartRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) {
out := new(google_protobuf1.Empty)
err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/Start", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/Start", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
@ -345,7 +342,7 @@ func (c *shimClient) Start(ctx context.Context, in *StartRequest, opts ...grpc.C
func (c *shimClient) Delete(ctx context.Context, in *DeleteRequest, opts ...grpc.CallOption) (*DeleteResponse, error) {
out := new(DeleteResponse)
err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/Delete", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/Delete", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
@ -354,7 +351,7 @@ func (c *shimClient) Delete(ctx context.Context, in *DeleteRequest, opts ...grpc
func (c *shimClient) DeleteProcess(ctx context.Context, in *DeleteProcessRequest, opts ...grpc.CallOption) (*DeleteResponse, error) {
out := new(DeleteResponse)
err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/DeleteProcess", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/DeleteProcess", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
@ -363,7 +360,7 @@ func (c *shimClient) DeleteProcess(ctx context.Context, in *DeleteProcessRequest
func (c *shimClient) State(ctx context.Context, in *StateRequest, opts ...grpc.CallOption) (*StateResponse, error) {
out := new(StateResponse)
err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/State", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/State", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
@ -372,7 +369,7 @@ func (c *shimClient) State(ctx context.Context, in *StateRequest, opts ...grpc.C
func (c *shimClient) Processes(ctx context.Context, in *ProcessesRequest, opts ...grpc.CallOption) (*ProcessesResponse, error) {
out := new(ProcessesResponse)
err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/Processes", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/Processes", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
@ -381,7 +378,7 @@ func (c *shimClient) Processes(ctx context.Context, in *ProcessesRequest, opts .
func (c *shimClient) Pause(ctx context.Context, in *PauseRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) {
out := new(google_protobuf1.Empty)
err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/Pause", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/Pause", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
@ -390,7 +387,7 @@ func (c *shimClient) Pause(ctx context.Context, in *PauseRequest, opts ...grpc.C
func (c *shimClient) Resume(ctx context.Context, in *ResumeRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) {
out := new(google_protobuf1.Empty)
err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/Resume", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/Resume", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
@ -399,7 +396,7 @@ func (c *shimClient) Resume(ctx context.Context, in *ResumeRequest, opts ...grpc
func (c *shimClient) Checkpoint(ctx context.Context, in *CheckpointRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) {
out := new(google_protobuf1.Empty)
err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/Checkpoint", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/Checkpoint", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
@ -408,7 +405,7 @@ func (c *shimClient) Checkpoint(ctx context.Context, in *CheckpointRequest, opts
func (c *shimClient) Exit(ctx context.Context, in *ExitRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) {
out := new(google_protobuf1.Empty)
err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/Exit", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/Exit", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
@ -416,7 +413,7 @@ func (c *shimClient) Exit(ctx context.Context, in *ExitRequest, opts ...grpc.Cal
}
func (c *shimClient) Events(ctx context.Context, in *EventsRequest, opts ...grpc.CallOption) (Shim_EventsClient, error) {
stream, err := grpc.NewClientStream(ctx, &_Shim_serviceDesc.Streams[0], c.cc, "/containerd.v1.services.shim.Shim/Events", opts...)
stream, err := grpc.NewClientStream(ctx, &_Shim_serviceDesc.Streams[0], c.cc, "/containerd.runtime.linux.shim.v1.Shim/Events", opts...)
if err != nil {
return nil, err
}
@ -449,7 +446,7 @@ func (x *shimEventsClient) Recv() (*containerd_v1_types1.Event, error) {
func (c *shimClient) Kill(ctx context.Context, in *KillRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) {
out := new(google_protobuf1.Empty)
err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/Kill", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/Kill", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
@ -458,7 +455,7 @@ func (c *shimClient) Kill(ctx context.Context, in *KillRequest, opts ...grpc.Cal
func (c *shimClient) Exec(ctx context.Context, in *ExecRequest, opts ...grpc.CallOption) (*ExecResponse, error) {
out := new(ExecResponse)
err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/Exec", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/Exec", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
@ -467,7 +464,7 @@ func (c *shimClient) Exec(ctx context.Context, in *ExecRequest, opts ...grpc.Cal
func (c *shimClient) Pty(ctx context.Context, in *PtyRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) {
out := new(google_protobuf1.Empty)
err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/Pty", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/Pty", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
@ -476,7 +473,7 @@ func (c *shimClient) Pty(ctx context.Context, in *PtyRequest, opts ...grpc.CallO
func (c *shimClient) CloseStdin(ctx context.Context, in *CloseStdinRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) {
out := new(google_protobuf1.Empty)
err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/CloseStdin", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/CloseStdin", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
@ -517,7 +514,7 @@ func _Shim_Create_Handler(srv interface{}, ctx context.Context, dec func(interfa
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.v1.services.shim.Shim/Create",
FullMethod: "/containerd.runtime.linux.shim.v1.Shim/Create",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ShimServer).Create(ctx, req.(*CreateRequest))
@ -535,7 +532,7 @@ func _Shim_Start_Handler(srv interface{}, ctx context.Context, dec func(interfac
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.v1.services.shim.Shim/Start",
FullMethod: "/containerd.runtime.linux.shim.v1.Shim/Start",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ShimServer).Start(ctx, req.(*StartRequest))
@ -553,7 +550,7 @@ func _Shim_Delete_Handler(srv interface{}, ctx context.Context, dec func(interfa
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.v1.services.shim.Shim/Delete",
FullMethod: "/containerd.runtime.linux.shim.v1.Shim/Delete",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ShimServer).Delete(ctx, req.(*DeleteRequest))
@ -571,7 +568,7 @@ func _Shim_DeleteProcess_Handler(srv interface{}, ctx context.Context, dec func(
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.v1.services.shim.Shim/DeleteProcess",
FullMethod: "/containerd.runtime.linux.shim.v1.Shim/DeleteProcess",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ShimServer).DeleteProcess(ctx, req.(*DeleteProcessRequest))
@ -589,7 +586,7 @@ func _Shim_State_Handler(srv interface{}, ctx context.Context, dec func(interfac
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.v1.services.shim.Shim/State",
FullMethod: "/containerd.runtime.linux.shim.v1.Shim/State",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ShimServer).State(ctx, req.(*StateRequest))
@ -607,7 +604,7 @@ func _Shim_Processes_Handler(srv interface{}, ctx context.Context, dec func(inte
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.v1.services.shim.Shim/Processes",
FullMethod: "/containerd.runtime.linux.shim.v1.Shim/Processes",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ShimServer).Processes(ctx, req.(*ProcessesRequest))
@ -625,7 +622,7 @@ func _Shim_Pause_Handler(srv interface{}, ctx context.Context, dec func(interfac
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.v1.services.shim.Shim/Pause",
FullMethod: "/containerd.runtime.linux.shim.v1.Shim/Pause",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ShimServer).Pause(ctx, req.(*PauseRequest))
@ -643,7 +640,7 @@ func _Shim_Resume_Handler(srv interface{}, ctx context.Context, dec func(interfa
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.v1.services.shim.Shim/Resume",
FullMethod: "/containerd.runtime.linux.shim.v1.Shim/Resume",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ShimServer).Resume(ctx, req.(*ResumeRequest))
@ -661,7 +658,7 @@ func _Shim_Checkpoint_Handler(srv interface{}, ctx context.Context, dec func(int
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.v1.services.shim.Shim/Checkpoint",
FullMethod: "/containerd.runtime.linux.shim.v1.Shim/Checkpoint",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ShimServer).Checkpoint(ctx, req.(*CheckpointRequest))
@ -679,7 +676,7 @@ func _Shim_Exit_Handler(srv interface{}, ctx context.Context, dec func(interface
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.v1.services.shim.Shim/Exit",
FullMethod: "/containerd.runtime.linux.shim.v1.Shim/Exit",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ShimServer).Exit(ctx, req.(*ExitRequest))
@ -718,7 +715,7 @@ func _Shim_Kill_Handler(srv interface{}, ctx context.Context, dec func(interface
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.v1.services.shim.Shim/Kill",
FullMethod: "/containerd.runtime.linux.shim.v1.Shim/Kill",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ShimServer).Kill(ctx, req.(*KillRequest))
@ -736,7 +733,7 @@ func _Shim_Exec_Handler(srv interface{}, ctx context.Context, dec func(interface
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.v1.services.shim.Shim/Exec",
FullMethod: "/containerd.runtime.linux.shim.v1.Shim/Exec",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ShimServer).Exec(ctx, req.(*ExecRequest))
@ -754,7 +751,7 @@ func _Shim_Pty_Handler(srv interface{}, ctx context.Context, dec func(interface{
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.v1.services.shim.Shim/Pty",
FullMethod: "/containerd.runtime.linux.shim.v1.Shim/Pty",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ShimServer).Pty(ctx, req.(*PtyRequest))
@ -772,7 +769,7 @@ func _Shim_CloseStdin_Handler(srv interface{}, ctx context.Context, dec func(int
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.v1.services.shim.Shim/CloseStdin",
FullMethod: "/containerd.runtime.linux.shim.v1.Shim/CloseStdin",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ShimServer).CloseStdin(ctx, req.(*CloseStdinRequest))
@ -781,7 +778,7 @@ func _Shim_CloseStdin_Handler(srv interface{}, ctx context.Context, dec func(int
}
var _Shim_serviceDesc = grpc.ServiceDesc{
ServiceName: "containerd.v1.services.shim.Shim",
ServiceName: "containerd.runtime.linux.shim.v1.Shim",
HandlerType: (*ShimServer)(nil),
Methods: []grpc.MethodDesc{
{
@ -1023,12 +1020,17 @@ func (m *DeleteResponse) MarshalTo(dAtA []byte) (int, error) {
_ = i
var l int
_ = l
if m.ExitStatus != 0 {
if m.Pid != 0 {
dAtA[i] = 0x8
i++
i = encodeVarintShim(dAtA, i, uint64(m.Pid))
}
if m.ExitStatus != 0 {
dAtA[i] = 0x10
i++
i = encodeVarintShim(dAtA, i, uint64(m.ExitStatus))
}
dAtA[i] = 0x12
dAtA[i] = 0x1a
i++
i = encodeVarintShim(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.ExitedAt)))
n1, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ExitedAt, dAtA[i:])
@ -1508,77 +1510,29 @@ func (m *CheckpointRequest) MarshalTo(dAtA []byte) (int, error) {
_ = i
var l int
_ = l
if m.Exit {
dAtA[i] = 0x8
i++
if m.Exit {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
if len(m.Path) > 0 {
dAtA[i] = 0xa
i++
i = encodeVarintShim(dAtA, i, uint64(len(m.Path)))
i += copy(dAtA[i:], m.Path)
}
if m.AllowTcp {
dAtA[i] = 0x10
i++
if m.AllowTcp {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i++
}
if m.AllowUnixSockets {
dAtA[i] = 0x18
i++
if m.AllowUnixSockets {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i++
}
if m.AllowTerminal {
dAtA[i] = 0x20
i++
if m.AllowTerminal {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i++
}
if m.FileLocks {
dAtA[i] = 0x28
i++
if m.FileLocks {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i++
}
if len(m.EmptyNamespaces) > 0 {
for _, s := range m.EmptyNamespaces {
dAtA[i] = 0x32
if len(m.Options) > 0 {
for k, _ := range m.Options {
dAtA[i] = 0x12
i++
l = len(s)
for l >= 1<<7 {
dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
l >>= 7
i++
}
dAtA[i] = uint8(l)
v := m.Options[k]
mapSize := 1 + len(k) + sovShim(uint64(len(k))) + 1 + len(v) + sovShim(uint64(len(v)))
i = encodeVarintShim(dAtA, i, uint64(mapSize))
dAtA[i] = 0xa
i++
i += copy(dAtA[i:], s)
i = encodeVarintShim(dAtA, i, uint64(len(k)))
i += copy(dAtA[i:], k)
dAtA[i] = 0x12
i++
i = encodeVarintShim(dAtA, i, uint64(len(v)))
i += copy(dAtA[i:], v)
}
}
if len(m.CheckpointPath) > 0 {
dAtA[i] = 0x3a
i++
i = encodeVarintShim(dAtA, i, uint64(len(m.CheckpointPath)))
i += copy(dAtA[i:], m.CheckpointPath)
}
return i, nil
}
@ -1683,6 +1637,9 @@ func (m *DeleteRequest) Size() (n int) {
func (m *DeleteResponse) Size() (n int) {
var l int
_ = l
if m.Pid != 0 {
n += 1 + sovShim(uint64(m.Pid))
}
if m.ExitStatus != 0 {
n += 1 + sovShim(uint64(m.ExitStatus))
}
@ -1885,31 +1842,18 @@ func (m *ProcessesResponse) Size() (n int) {
func (m *CheckpointRequest) Size() (n int) {
var l int
_ = l
if m.Exit {
n += 2
}
if m.AllowTcp {
n += 2
}
if m.AllowUnixSockets {
n += 2
}
if m.AllowTerminal {
n += 2
}
if m.FileLocks {
n += 2
}
if len(m.EmptyNamespaces) > 0 {
for _, s := range m.EmptyNamespaces {
l = len(s)
n += 1 + l + sovShim(uint64(l))
}
}
l = len(m.CheckpointPath)
l = len(m.Path)
if l > 0 {
n += 1 + l + sovShim(uint64(l))
}
if len(m.Options) > 0 {
for k, v := range m.Options {
_ = k
_ = v
mapEntrySize := 1 + len(k) + sovShim(uint64(len(k))) + 1 + len(v) + sovShim(uint64(len(v)))
n += mapEntrySize + 1 + sovShim(uint64(mapEntrySize))
}
}
return n
}
@ -1979,6 +1923,7 @@ func (this *DeleteResponse) String() string {
return "nil"
}
s := strings.Join([]string{`&DeleteResponse{`,
`Pid:` + fmt.Sprintf("%v", this.Pid) + `,`,
`ExitStatus:` + fmt.Sprintf("%v", this.ExitStatus) + `,`,
`ExitedAt:` + strings.Replace(strings.Replace(this.ExitedAt.String(), "Timestamp", "google_protobuf3.Timestamp", 1), `&`, ``, 1) + `,`,
`}`,
@ -2152,14 +2097,19 @@ func (this *CheckpointRequest) String() string {
if this == nil {
return "nil"
}
keysForOptions := make([]string, 0, len(this.Options))
for k, _ := range this.Options {
keysForOptions = append(keysForOptions, k)
}
github_com_gogo_protobuf_sortkeys.Strings(keysForOptions)
mapStringForOptions := "map[string]string{"
for _, k := range keysForOptions {
mapStringForOptions += fmt.Sprintf("%v: %v,", k, this.Options[k])
}
mapStringForOptions += "}"
s := strings.Join([]string{`&CheckpointRequest{`,
`Exit:` + fmt.Sprintf("%v", this.Exit) + `,`,
`AllowTcp:` + fmt.Sprintf("%v", this.AllowTcp) + `,`,
`AllowUnixSockets:` + fmt.Sprintf("%v", this.AllowUnixSockets) + `,`,
`AllowTerminal:` + fmt.Sprintf("%v", this.AllowTerminal) + `,`,
`FileLocks:` + fmt.Sprintf("%v", this.FileLocks) + `,`,
`EmptyNamespaces:` + fmt.Sprintf("%v", this.EmptyNamespaces) + `,`,
`CheckpointPath:` + fmt.Sprintf("%v", this.CheckpointPath) + `,`,
`Path:` + fmt.Sprintf("%v", this.Path) + `,`,
`Options:` + mapStringForOptions + `,`,
`}`,
}, "")
return s
@ -2724,6 +2674,25 @@ func (m *DeleteResponse) Unmarshal(dAtA []byte) error {
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType)
}
m.Pid = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowShim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Pid |= (uint32(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field ExitStatus", wireType)
}
@ -2742,7 +2711,7 @@ func (m *DeleteResponse) Unmarshal(dAtA []byte) error {
break
}
}
case 2:
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ExitedAt", wireType)
}
@ -4246,108 +4215,8 @@ func (m *CheckpointRequest) Unmarshal(dAtA []byte) error {
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Exit", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowShim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.Exit = bool(v != 0)
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field AllowTcp", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowShim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.AllowTcp = bool(v != 0)
case 3:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field AllowUnixSockets", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowShim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.AllowUnixSockets = bool(v != 0)
case 4:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field AllowTerminal", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowShim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.AllowTerminal = bool(v != 0)
case 5:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field FileLocks", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowShim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.FileLocks = bool(v != 0)
case 6:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field EmptyNamespaces", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
@ -4372,13 +4241,13 @@ func (m *CheckpointRequest) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.EmptyNamespaces = append(m.EmptyNamespaces, string(dAtA[iNdEx:postIndex]))
m.Path = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 7:
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field CheckpointPath", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
}
var stringLen uint64
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowShim
@ -4388,20 +4257,107 @@ func (m *CheckpointRequest) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
if msglen < 0 {
return ErrInvalidLengthShim
}
postIndex := iNdEx + intStringLen
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.CheckpointPath = string(dAtA[iNdEx:postIndex])
var keykey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowShim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
keykey |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
var stringLenmapkey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowShim
}
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 ErrInvalidLengthShim
}
postStringIndexmapkey := iNdEx + intStringLenmapkey
if postStringIndexmapkey > l {
return io.ErrUnexpectedEOF
}
mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
iNdEx = postStringIndexmapkey
if m.Options == nil {
m.Options = make(map[string]string)
}
if iNdEx < postIndex {
var valuekey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowShim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
valuekey |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
var stringLenmapvalue uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowShim
}
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 ErrInvalidLengthShim
}
postStringIndexmapvalue := iNdEx + intStringLenmapvalue
if postStringIndexmapvalue > l {
return io.ErrUnexpectedEOF
}
mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
iNdEx = postStringIndexmapvalue
m.Options[mapkey] = mapvalue
} else {
var mapvalue string
m.Options[mapkey] = mapvalue
}
iNdEx = postIndex
default:
iNdEx = preIndex
@ -4534,78 +4490,75 @@ func init() {
}
var fileDescriptorShim = []byte{
// 1168 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xcd, 0x6e, 0x23, 0x45,
0x10, 0xce, 0xd8, 0x8e, 0x63, 0x97, 0xd7, 0x4e, 0xd2, 0x8a, 0xa2, 0x59, 0x07, 0x9c, 0x68, 0xa4,
0xd5, 0x3a, 0x59, 0x18, 0xb3, 0xd9, 0xdb, 0x0a, 0x0e, 0xf9, 0x43, 0x2c, 0x04, 0xb0, 0x26, 0xe1,
0x84, 0x84, 0x35, 0x19, 0x77, 0xec, 0x26, 0xe3, 0xe9, 0x61, 0xba, 0x9d, 0x4d, 0x6e, 0x3c, 0x00,
0x07, 0xae, 0xdc, 0x39, 0xf0, 0x28, 0x39, 0x72, 0x83, 0xd3, 0xc2, 0xe6, 0x49, 0x50, 0xff, 0xcc,
0x8f, 0x93, 0x8c, 0xed, 0x48, 0x5c, 0x46, 0xdd, 0xd5, 0xd5, 0xd5, 0x55, 0xf5, 0x7d, 0x55, 0x35,
0xf0, 0xd9, 0x80, 0xf0, 0xe1, 0xf8, 0xcc, 0xf6, 0xe8, 0xa8, 0xe3, 0xd1, 0x80, 0xbb, 0x24, 0xc0,
0x51, 0x3f, 0xbb, 0x74, 0x43, 0xd2, 0x61, 0x38, 0xba, 0x24, 0x1e, 0x66, 0x1d, 0x36, 0x24, 0x23,
0xf9, 0xb1, 0xc3, 0x88, 0x72, 0x8a, 0x36, 0x52, 0x45, 0xfb, 0xf2, 0xa5, 0x1d, 0xeb, 0xd9, 0x42,
0xa5, 0xf9, 0x74, 0x40, 0xe9, 0xc0, 0xc7, 0x1d, 0xa9, 0x7a, 0x36, 0x3e, 0xef, 0xb8, 0xc1, 0xb5,
0xba, 0xd7, 0xdc, 0xb8, 0x7b, 0x84, 0x47, 0x21, 0x8f, 0x0f, 0xd7, 0x06, 0x74, 0x40, 0xe5, 0xb2,
0x23, 0x56, 0x5a, 0xfa, 0xe9, 0x5c, 0x9e, 0xf2, 0xeb, 0x10, 0xb3, 0xce, 0x88, 0x8e, 0x03, 0xae,
0xbe, 0xfa, 0xf6, 0xeb, 0x47, 0xdc, 0xe6, 0x2e, 0xbb, 0x90, 0x1f, 0x7d, 0x77, 0xf3, 0xae, 0xb3,
0x9c, 0x8c, 0x30, 0xe3, 0xee, 0x28, 0x54, 0x0a, 0xd6, 0x5f, 0x05, 0xa8, 0x1f, 0x44, 0xd8, 0xe5,
0xd8, 0xc1, 0x3f, 0x8d, 0x31, 0xe3, 0x68, 0x1d, 0x0a, 0xa4, 0x6f, 0x1a, 0x5b, 0x46, 0xbb, 0xba,
0x5f, 0xbe, 0x7d, 0xb7, 0x59, 0x78, 0x73, 0xe8, 0x14, 0x48, 0x1f, 0xad, 0x43, 0xf9, 0x6c, 0x1c,
0xf4, 0x7d, 0x6c, 0x16, 0xc4, 0x99, 0xa3, 0x77, 0xc8, 0x84, 0xa5, 0x68, 0x1c, 0x08, 0xbb, 0x66,
0x51, 0x1e, 0xc4, 0x5b, 0xf4, 0x14, 0x2a, 0x01, 0xed, 0x85, 0xe4, 0x92, 0x72, 0xb3, 0xb4, 0x65,
0xb4, 0x2b, 0xce, 0x52, 0x40, 0xbb, 0x62, 0x8b, 0x9a, 0x50, 0xe1, 0x38, 0x1a, 0x91, 0xc0, 0xf5,
0xcd, 0x45, 0x79, 0x94, 0xec, 0xd1, 0x1a, 0x2c, 0x32, 0xde, 0x27, 0x81, 0x59, 0x96, 0xe6, 0xd4,
0x46, 0x3c, 0xcf, 0x78, 0x9f, 0x8e, 0xb9, 0xb9, 0xa4, 0x9e, 0x57, 0x3b, 0x2d, 0xc7, 0x51, 0x64,
0x56, 0x12, 0x39, 0x8e, 0x22, 0xb4, 0x0b, 0xe5, 0x88, 0x52, 0x7e, 0xce, 0xcc, 0xea, 0x56, 0xb1,
0x5d, 0xdb, 0x6d, 0xda, 0x93, 0x78, 0xcb, 0x7c, 0xd9, 0x5f, 0x8b, 0x3c, 0x3b, 0x5a, 0x13, 0xb5,
0x00, 0xbc, 0x21, 0xf6, 0x2e, 0x42, 0x4a, 0x02, 0x6e, 0x82, 0xb4, 0x97, 0x91, 0xa0, 0x17, 0xb0,
0x1a, 0xba, 0x11, 0x0e, 0x78, 0x2f, 0xa3, 0x56, 0x93, 0x6a, 0x2b, 0xea, 0xe0, 0x20, 0x91, 0x5b,
0x16, 0x34, 0xe2, 0xc4, 0xb2, 0x90, 0x06, 0x0c, 0xa3, 0x15, 0x28, 0x86, 0x3a, 0xb5, 0x75, 0x47,
0x2c, 0xad, 0x06, 0x3c, 0x39, 0xe1, 0x6e, 0xc4, 0x75, 0xee, 0xad, 0x65, 0xa8, 0x1f, 0x62, 0x1f,
0x27, 0x60, 0x58, 0x1c, 0x1a, 0xb1, 0x40, 0x1b, 0xd9, 0x84, 0x1a, 0xbe, 0x22, 0xbc, 0xc7, 0xb8,
0xcb, 0xc7, 0x4c, 0x1b, 0x03, 0x21, 0x3a, 0x91, 0x12, 0xb4, 0x07, 0x55, 0xb1, 0xc3, 0xfd, 0x9e,
0xcb, 0x25, 0x54, 0x22, 0x76, 0x45, 0x03, 0x3b, 0xa6, 0x81, 0x7d, 0x1a, 0xd3, 0x60, 0xbf, 0x72,
0xf3, 0x6e, 0x73, 0xe1, 0xd7, 0x7f, 0x36, 0x0d, 0xa7, 0xa2, 0xae, 0xed, 0x71, 0xab, 0x0d, 0x6b,
0xea, 0xd5, 0x6e, 0x44, 0x3d, 0xcc, 0x58, 0x4c, 0x8d, 0xfb, 0x01, 0xfc, 0x66, 0x40, 0xed, 0xe8,
0x0a, 0x7b, 0xb1, 0x46, 0x16, 0x57, 0x23, 0x0f, 0xd7, 0xc2, 0xc3, 0xb8, 0x16, 0x73, 0x70, 0x2d,
0x4d, 0xe0, 0xda, 0x86, 0x12, 0x0b, 0xb1, 0x27, 0x59, 0x53, 0xdb, 0x5d, 0xbb, 0x17, 0xd9, 0x5e,
0x70, 0xed, 0x48, 0x0d, 0xeb, 0x10, 0xca, 0x8e, 0x4f, 0x46, 0x84, 0x23, 0x04, 0x25, 0x01, 0xb7,
0x22, 0xb5, 0x23, 0xd7, 0x42, 0x36, 0x74, 0xa3, 0xbe, 0x74, 0xa6, 0xe4, 0xc8, 0xb5, 0x90, 0x31,
0x7a, 0xae, 0x3c, 0x29, 0x39, 0x72, 0x6d, 0x6d, 0xc1, 0x13, 0x15, 0x60, 0x2e, 0x88, 0xc7, 0x00,
0x5d, 0x7e, 0x9d, 0x9b, 0x23, 0x11, 0xf7, 0x5b, 0xd2, 0xe7, 0x43, 0xf9, 0x54, 0xdd, 0x51, 0x1b,
0x11, 0xdf, 0x10, 0x93, 0xc1, 0x50, 0xbd, 0x56, 0x77, 0xf4, 0x4e, 0x50, 0xe0, 0xe8, 0x12, 0x07,
0x3c, 0x4e, 0xba, 0xe6, 0x48, 0x4a, 0x89, 0xdf, 0x0b, 0x50, 0xd7, 0x02, 0xed, 0xd2, 0x63, 0x2b,
0x56, 0xbb, 0x58, 0x4c, 0x5d, 0x7c, 0x25, 0x92, 0x2d, 0xf9, 0x24, 0x92, 0xdd, 0xd8, 0xdd, 0x78,
0xb0, 0x58, 0x14, 0xc1, 0x1c, 0xad, 0x8a, 0x5e, 0x43, 0x35, 0x54, 0xfc, 0xc0, 0xcc, 0x5c, 0x94,
0x45, 0xf6, 0xc1, 0x83, 0xf7, 0x62, 0x16, 0xa5, 0xea, 0xff, 0x53, 0x8d, 0x67, 0xd9, 0x56, 0x9d,
0x64, 0x9b, 0x48, 0x5b, 0xd7, 0x1d, 0x33, 0x9c, 0x29, 0x2d, 0x07, 0xb3, 0xf1, 0x28, 0x11, 0xd4,
0x05, 0x73, 0x49, 0x52, 0x7a, 0x6f, 0xa0, 0xf6, 0x15, 0xf1, 0xfd, 0xb4, 0x0b, 0x96, 0x19, 0x19,
0xc4, 0x34, 0xae, 0x3b, 0x7a, 0x27, 0x72, 0xe7, 0xfa, 0xbe, 0x4c, 0x68, 0xc5, 0x11, 0xcb, 0xfb,
0xd9, 0xb4, 0x9e, 0xc1, 0xea, 0x81, 0x4f, 0x19, 0x3e, 0x11, 0x41, 0xe5, 0xd7, 0xce, 0x0e, 0xac,
0x74, 0xe3, 0x84, 0xcc, 0x68, 0xbe, 0xd6, 0xb7, 0xb0, 0x9a, 0xd1, 0xd5, 0xb8, 0x4f, 0x00, 0x60,
0x3c, 0x0a, 0x00, 0xeb, 0x97, 0x02, 0xac, 0xa6, 0xcd, 0x2a, 0x7e, 0x1e, 0x41, 0x49, 0x34, 0x01,
0x5d, 0xba, 0x72, 0x8d, 0x36, 0xa0, 0xea, 0xfa, 0x3e, 0x7d, 0xdb, 0xe3, 0x5e, 0xa8, 0xe3, 0xae,
0x48, 0xc1, 0xa9, 0x17, 0xa2, 0x8f, 0x00, 0xa9, 0xc3, 0x71, 0x40, 0xae, 0x7a, 0x8c, 0x7a, 0x17,
0x98, 0x33, 0x99, 0x8b, 0x8a, 0xb3, 0x22, 0x4f, 0xbe, 0x0b, 0xc8, 0xd5, 0x89, 0x92, 0xa3, 0x67,
0xd0, 0xd0, 0xa6, 0x62, 0xd4, 0xd4, 0x58, 0xa8, 0x2b, 0x7b, 0x71, 0xa3, 0xf8, 0x10, 0xe0, 0x9c,
0xf8, 0xb8, 0xe7, 0x53, 0xef, 0x82, 0xe9, 0xf1, 0x50, 0x15, 0x92, 0x63, 0x21, 0x40, 0xdb, 0xb0,
0x22, 0x47, 0x6e, 0x2f, 0x70, 0x47, 0x98, 0x85, 0xae, 0x87, 0x99, 0x59, 0xde, 0x2a, 0xb6, 0xab,
0xce, 0xb2, 0x94, 0x7f, 0x93, 0x88, 0xd1, 0x73, 0x58, 0x4e, 0x3b, 0x75, 0x2f, 0x74, 0xf9, 0x50,
0x33, 0xab, 0x91, 0x8a, 0xbb, 0x2e, 0x1f, 0xee, 0xfe, 0x01, 0x50, 0x3a, 0x19, 0x92, 0x11, 0x72,
0xa1, 0xac, 0xba, 0x36, 0xda, 0xb1, 0xa7, 0xfc, 0x20, 0xd8, 0x13, 0x33, 0xb3, 0xf9, 0x62, 0x2e,
0x5d, 0x0d, 0xdb, 0x97, 0xb0, 0x28, 0x9b, 0x3e, 0xda, 0x9e, 0x7a, 0x2b, 0x3b, 0x18, 0x9a, 0xeb,
0xf7, 0xfa, 0xdc, 0x91, 0x08, 0x55, 0xb8, 0xab, 0x3a, 0xf5, 0x0c, 0x77, 0x27, 0xa6, 0xca, 0x0c,
0x77, 0xef, 0x0c, 0x1c, 0x1a, 0xcf, 0x24, 0xcd, 0x22, 0xf4, 0x72, 0x8e, 0xdb, 0x93, 0x83, 0xe3,
0x71, 0x0f, 0xfe, 0x20, 0xf3, 0xc3, 0xf1, 0xec, 0xfc, 0xa4, 0x11, 0xed, 0xcc, 0xa3, 0xaa, 0xed,
0xff, 0x08, 0xd5, 0xa4, 0x96, 0xd0, 0xc7, 0x53, 0x2f, 0xde, 0xad, 0xcf, 0xa6, 0x3d, 0xaf, 0x7a,
0x8a, 0xb5, 0xec, 0x42, 0x33, 0x62, 0xc9, 0x76, 0xaa, 0x5c, 0xac, 0x8f, 0xa1, 0xac, 0x3a, 0xd8,
0x0c, 0xac, 0x27, 0xda, 0x5c, 0xae, 0xb5, 0x53, 0x80, 0xb4, 0xfe, 0xd1, 0xf4, 0xb8, 0xee, 0x35,
0x8a, 0x5c, 0xab, 0x5f, 0x40, 0x49, 0x34, 0x55, 0xd4, 0x9e, 0x6a, 0x2f, 0xd3, 0x77, 0x73, 0x2d,
0x39, 0x50, 0x56, 0x73, 0x70, 0x46, 0xb4, 0x13, 0xc3, 0xb2, 0xf9, 0xf0, 0x5f, 0x9e, 0xd4, 0xf9,
0xc4, 0x10, 0xde, 0x89, 0x1e, 0x3f, 0xc3, 0xbb, 0xcc, 0x18, 0xc8, 0xf5, 0xee, 0x7b, 0x11, 0x27,
0xf6, 0x66, 0xc6, 0x99, 0xfc, 0x19, 0x35, 0xb7, 0xe7, 0xd0, 0xd4, 0xa4, 0xf9, 0x1c, 0x8a, 0x5d,
0x7e, 0x8d, 0x9e, 0x4f, 0xa7, 0x4c, 0xf2, 0xcb, 0x31, 0x15, 0xe2, 0x64, 0x0e, 0xcd, 0x82, 0xf8,
0xee, 0xc0, 0xca, 0xb3, 0xba, 0x6f, 0xde, 0xbc, 0x6f, 0x2d, 0xfc, 0xfd, 0xbe, 0xb5, 0xf0, 0xf3,
0x6d, 0xcb, 0xb8, 0xb9, 0x6d, 0x19, 0x7f, 0xde, 0xb6, 0x8c, 0x7f, 0x6f, 0x5b, 0xc6, 0x59, 0x59,
0x6a, 0xbe, 0xfa, 0x2f, 0x00, 0x00, 0xff, 0xff, 0xd9, 0x7f, 0x4d, 0x1e, 0x99, 0x0d, 0x00, 0x00,
// 1114 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xcd, 0x6f, 0xe3, 0x44,
0x14, 0xaf, 0x93, 0x34, 0x4d, 0x5e, 0x9a, 0xd2, 0x8e, 0xaa, 0xca, 0x9b, 0x45, 0x69, 0x65, 0x09,
0xa9, 0xe2, 0xc3, 0xd9, 0x4d, 0x25, 0x84, 0x2a, 0x90, 0xe8, 0xd7, 0x61, 0xb5, 0xac, 0x1a, 0x5c,
0x24, 0x04, 0x97, 0xca, 0x4d, 0xa6, 0xf1, 0xa8, 0xb6, 0xc7, 0x78, 0xc6, 0xa1, 0xb9, 0x71, 0xe2,
0x0c, 0x47, 0xee, 0xfc, 0x1f, 0x5c, 0x7b, 0xe4, 0x06, 0xa7, 0x85, 0xed, 0x5f, 0x82, 0xe6, 0xc3,
0x8e, 0xd3, 0xd6, 0xc4, 0x5d, 0xed, 0xc5, 0x9a, 0xf7, 0xe6, 0xbd, 0x37, 0xef, 0xe3, 0xf7, 0xde,
0x33, 0x7c, 0x31, 0x26, 0xdc, 0x4b, 0x2e, 0xec, 0x21, 0x0d, 0x7a, 0x43, 0x1a, 0x72, 0x97, 0x84,
0x38, 0x1e, 0xe5, 0x8f, 0x6e, 0x44, 0x7a, 0x0c, 0xc7, 0x13, 0x32, 0xc4, 0xac, 0xc7, 0x3c, 0x12,
0xc8, 0x8f, 0x1d, 0xc5, 0x94, 0x53, 0xb4, 0x33, 0x13, 0xb4, 0xe3, 0x24, 0xe4, 0x24, 0xc0, 0xb6,
0x4f, 0xc2, 0xe4, 0xda, 0x96, 0x42, 0x93, 0xe7, 0x9d, 0x27, 0x63, 0x4a, 0xc7, 0x3e, 0xee, 0x49,
0xf9, 0x8b, 0xe4, 0xb2, 0xe7, 0x86, 0x53, 0xa5, 0xdc, 0x79, 0x7a, 0xf7, 0x0a, 0x07, 0x11, 0x4f,
0x2f, 0x37, 0xc7, 0x74, 0x4c, 0xe5, 0xb1, 0x27, 0x4e, 0x9a, 0xfb, 0x79, 0x29, 0x77, 0xf9, 0x34,
0xc2, 0xac, 0x17, 0xd0, 0x24, 0xe4, 0xea, 0xab, 0xb5, 0xf7, 0x1f, 0xa1, 0xcd, 0x5d, 0x76, 0x25,
0x3f, 0x5a, 0x77, 0xfb, 0xae, 0xb3, 0x22, 0x56, 0xc6, 0xdd, 0x20, 0x52, 0x02, 0xd6, 0x5f, 0x15,
0x68, 0x1f, 0xc5, 0xd8, 0xe5, 0xd8, 0xc1, 0x3f, 0x24, 0x98, 0x71, 0xb4, 0x05, 0x15, 0x32, 0x32,
0x8d, 0x1d, 0x63, 0xb7, 0x79, 0x58, 0xbf, 0x7d, 0xbd, 0x5d, 0x79, 0x71, 0xec, 0x54, 0xc8, 0x08,
0x6d, 0x41, 0xfd, 0x22, 0x09, 0x47, 0x3e, 0x36, 0x2b, 0xe2, 0xce, 0xd1, 0x14, 0x32, 0x61, 0x45,
0xe7, 0xd0, 0xac, 0xca, 0x8b, 0x94, 0x44, 0x4f, 0xa0, 0x11, 0xd2, 0xf3, 0x88, 0x4c, 0x28, 0x37,
0x6b, 0x3b, 0xc6, 0x6e, 0xc3, 0x59, 0x09, 0xe9, 0x40, 0x90, 0xa8, 0x03, 0x0d, 0x8e, 0xe3, 0x80,
0x84, 0xae, 0x6f, 0x2e, 0xcb, 0xab, 0x8c, 0x46, 0x9b, 0xb0, 0xcc, 0xf8, 0x88, 0x84, 0x66, 0x5d,
0x9a, 0x53, 0x84, 0x78, 0x9e, 0xf1, 0x11, 0x4d, 0xb8, 0xb9, 0xa2, 0x9e, 0x57, 0x94, 0xe6, 0xe3,
0x38, 0x36, 0x1b, 0x19, 0x1f, 0xc7, 0x31, 0xea, 0x43, 0x3d, 0xa6, 0x94, 0x5f, 0x32, 0xb3, 0xb9,
0x53, 0xdd, 0x6d, 0xf5, 0x3b, 0x76, 0xae, 0xe8, 0x93, 0xe7, 0xb6, 0xcc, 0x97, 0xfd, 0x4a, 0xe4,
0xd9, 0xd1, 0x92, 0xa8, 0x0b, 0x30, 0xf4, 0xf0, 0xf0, 0x2a, 0xa2, 0x24, 0xe4, 0x26, 0x48, 0x7b,
0x39, 0x0e, 0xfa, 0x08, 0x36, 0x22, 0x37, 0xc6, 0x21, 0x3f, 0xcf, 0x89, 0xb5, 0xa4, 0xd8, 0xba,
0xba, 0x38, 0xca, 0xf8, 0x96, 0x05, 0x6b, 0x69, 0x62, 0x59, 0x44, 0x43, 0x86, 0xd1, 0x3a, 0x54,
0x23, 0x9d, 0xda, 0xb6, 0x23, 0x8e, 0xd6, 0x1a, 0xac, 0x9e, 0x71, 0x37, 0xe6, 0x3a, 0xf7, 0xd6,
0x7b, 0xd0, 0x3e, 0xc6, 0x3e, 0xce, 0x8a, 0x61, 0xfd, 0x6c, 0xc0, 0x5a, 0xca, 0x29, 0xb2, 0x82,
0xb6, 0xa1, 0x85, 0xaf, 0x09, 0x3f, 0x67, 0xdc, 0xe5, 0x09, 0x93, 0xe5, 0x69, 0x3b, 0x20, 0x58,
0x67, 0x92, 0x83, 0x0e, 0xa0, 0x29, 0x28, 0x3c, 0x3a, 0x77, 0xb9, 0x2c, 0x92, 0x48, 0x87, 0x42,
0x86, 0x9d, 0x22, 0xc3, 0xfe, 0x26, 0x45, 0xc6, 0x61, 0xe3, 0xe6, 0xf5, 0xf6, 0xd2, 0x2f, 0xff,
0x6c, 0x1b, 0x4e, 0x43, 0xa9, 0x1d, 0x70, 0x6b, 0x17, 0x36, 0x95, 0x1f, 0x83, 0x98, 0x0e, 0x31,
0x63, 0x29, 0x5a, 0xee, 0xc7, 0xf4, 0x9b, 0x01, 0xad, 0x93, 0x6b, 0x3c, 0x4c, 0x25, 0xf2, 0xa5,
0x36, 0x8a, 0x4a, 0x5d, 0x79, 0xb8, 0xd4, 0xd5, 0x82, 0x52, 0xd7, 0xe6, 0x4a, 0xbd, 0x0b, 0x35,
0x16, 0xe1, 0xa1, 0x04, 0x52, 0xab, 0xbf, 0x79, 0x2f, 0xb2, 0x83, 0x70, 0xea, 0x48, 0x09, 0xeb,
0x18, 0xea, 0x8e, 0x4f, 0x02, 0xc2, 0x11, 0x82, 0x9a, 0x40, 0x80, 0xc2, 0xb9, 0x23, 0xcf, 0x82,
0xe7, 0xb9, 0xf1, 0x48, 0x3a, 0x53, 0x73, 0xe4, 0x59, 0xf0, 0x18, 0xbd, 0x54, 0x9e, 0xd4, 0x1c,
0x79, 0xb6, 0x76, 0x60, 0x55, 0x05, 0x58, 0x58, 0xd7, 0xaf, 0x00, 0x06, 0x7c, 0x5a, 0x98, 0x23,
0x11, 0xf7, 0x8f, 0x64, 0xc4, 0x3d, 0x5d, 0x2b, 0x45, 0x88, 0xf8, 0x3c, 0x4c, 0xc6, 0x9e, 0x7a,
0xad, 0xed, 0x68, 0x4a, 0xa0, 0xe2, 0x64, 0x82, 0x43, 0x9e, 0x26, 0x5d, 0xc3, 0x66, 0x86, 0x92,
0xdf, 0x2b, 0xd0, 0xd6, 0x0c, 0xed, 0xd2, 0x63, 0x9b, 0x58, 0xbb, 0x58, 0x9d, 0xb9, 0xb8, 0x27,
0x92, 0x2d, 0xf1, 0x24, 0x92, 0xbd, 0xd6, 0x7f, 0xfa, 0x60, 0xff, 0x28, 0x80, 0x39, 0x5a, 0x14,
0xed, 0x43, 0x33, 0x52, 0xf8, 0xc0, 0xcc, 0x5c, 0x96, 0x7d, 0xf7, 0xfe, 0x83, 0x7a, 0x29, 0x8a,
0x66, 0xe2, 0xef, 0xa8, 0xed, 0xf3, 0x68, 0x6b, 0xce, 0xa3, 0x4d, 0xa4, 0x6d, 0xe0, 0x26, 0x0c,
0xe7, 0xba, 0xcd, 0xc1, 0x2c, 0x09, 0x32, 0x46, 0x5b, 0x20, 0x97, 0x64, 0xdd, 0xf8, 0x02, 0x5a,
0x2f, 0x89, 0xef, 0xcf, 0x06, 0x63, 0x9d, 0x91, 0x71, 0x0a, 0xe3, 0xb6, 0xa3, 0x29, 0x91, 0x3b,
0xd7, 0xf7, 0x65, 0x42, 0x1b, 0x8e, 0x38, 0xde, 0xcf, 0xa6, 0xf5, 0x01, 0x6c, 0x1c, 0xf9, 0x94,
0xe1, 0x33, 0x11, 0x54, 0x71, 0xef, 0x7c, 0x08, 0xeb, 0x83, 0x34, 0x21, 0x0b, 0xe6, 0xb1, 0x75,
0x0a, 0x1b, 0x39, 0x59, 0x5d, 0xf7, 0xb9, 0x02, 0x18, 0x8f, 0x2a, 0x80, 0xf5, 0x87, 0x01, 0x1b,
0xb3, 0xf9, 0x95, 0x3e, 0x8f, 0xa0, 0x16, 0xb9, 0xdc, 0x4b, 0x1b, 0x45, 0x9c, 0xd1, 0xf7, 0xb0,
0x42, 0x23, 0x4e, 0x68, 0x28, 0x86, 0x8d, 0x78, 0xe3, 0x4b, 0x7b, 0xd1, 0x46, 0xb5, 0xef, 0x59,
0xb6, 0x4f, 0x95, 0x89, 0x93, 0x90, 0xc7, 0x53, 0x27, 0x35, 0xd8, 0xd9, 0x87, 0xd5, 0xfc, 0x85,
0x48, 0xd2, 0x15, 0x9e, 0xea, 0xe7, 0xc5, 0x51, 0x00, 0x65, 0xe2, 0xfa, 0x49, 0x0a, 0x61, 0x45,
0xec, 0x57, 0x3e, 0x33, 0xfa, 0xbf, 0xb6, 0xa0, 0x76, 0xe6, 0x91, 0x00, 0x5d, 0x41, 0x5d, 0xcd,
0x5e, 0xd4, 0x2b, 0xe1, 0x59, 0x7e, 0xfd, 0x75, 0x9e, 0x95, 0x57, 0xd0, 0x39, 0x3f, 0x85, 0x65,
0x39, 0xc4, 0x91, 0xbd, 0x58, 0x35, 0x3f, 0xed, 0x3b, 0x5b, 0xf7, 0x26, 0xd5, 0x89, 0xf8, 0x95,
0x10, 0xde, 0xab, 0x59, 0x5b, 0xc6, 0xfb, 0xb9, 0x7d, 0x51, 0xc6, 0xfb, 0x3b, 0xeb, 0x64, 0x9a,
0xae, 0x1c, 0x8d, 0x08, 0xf4, 0x69, 0x59, 0x13, 0xf3, 0x9b, 0xe0, 0x2d, 0x9e, 0xf6, 0x64, 0xe2,
0x38, 0x2e, 0x99, 0xb8, 0x59, 0x94, 0xbd, 0xd2, 0xf2, 0xfa, 0x25, 0x0e, 0xcd, 0xac, 0x57, 0x50,
0x7f, 0xb1, 0xf6, 0xdd, 0x26, 0xec, 0xec, 0x3d, 0x4a, 0x67, 0x06, 0x0c, 0x39, 0x6f, 0xca, 0xc4,
0x97, 0x1f, 0x4c, 0x85, 0xc0, 0xf8, 0x1a, 0xea, 0x6a, 0x60, 0x95, 0x01, 0xc6, 0xdc, 0x68, 0x2b,
0x34, 0xf9, 0x1d, 0xc0, 0xac, 0x33, 0xd1, 0xde, 0x5b, 0xf4, 0x71, 0xa1, 0xe9, 0x57, 0x50, 0x13,
0xd3, 0x14, 0x7d, 0xb2, 0xd8, 0x68, 0x6e, 0xea, 0x16, 0x9a, 0xfb, 0x16, 0xea, 0x6a, 0x0b, 0x96,
0x09, 0x7e, 0x6e, 0x5f, 0x76, 0x1e, 0xfe, 0xf7, 0x93, 0x32, 0xcf, 0x0c, 0xe1, 0xa7, 0x18, 0xf3,
0x65, 0xfc, 0xcc, 0xad, 0x83, 0x42, 0x3f, 0xb1, 0x08, 0x1b, 0x0f, 0xcb, 0x85, 0x9d, 0xfd, 0x26,
0x75, 0xec, 0xb2, 0xe2, 0x1a, 0x5c, 0x2f, 0xa1, 0x3a, 0xe0, 0x53, 0xf4, 0x71, 0x09, 0x68, 0x65,
0x7f, 0x22, 0xff, 0x8b, 0x82, 0x6c, 0x3d, 0x95, 0x42, 0xc1, 0xdd, 0x65, 0x56, 0x64, 0xfa, 0xd0,
0xbc, 0x79, 0xd3, 0x5d, 0xfa, 0xfb, 0x4d, 0x77, 0xe9, 0xa7, 0xdb, 0xae, 0x71, 0x73, 0xdb, 0x35,
0xfe, 0xbc, 0xed, 0x1a, 0xff, 0xde, 0x76, 0x8d, 0x8b, 0xba, 0x94, 0xdc, 0xfb, 0x2f, 0x00, 0x00,
0xff, 0xff, 0xc6, 0xa3, 0x7c, 0xe5, 0xcd, 0x0d, 0x00, 0x00,
}

16
api/services/shim/shim.proto
View File

@ -1,6 +1,6 @@
syntax = "proto3";
package containerd.v1.services.shim;
package containerd.runtime.linux.shim.v1;
import "google/protobuf/any.proto";
import "google/protobuf/empty.proto";
@ -57,8 +57,9 @@ message DeleteRequest {
}
message DeleteResponse {
uint32 exit_status = 1;
google.protobuf.Timestamp exited_at = 2 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
uint32 pid = 1;
uint32 exit_status = 2;
google.protobuf.Timestamp exited_at = 3 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
}
message DeleteProcessRequest {
@ -135,11 +136,6 @@ message ProcessesResponse{
}
message CheckpointRequest {
bool exit = 1;
bool allow_tcp = 2;
bool allow_unix_sockets = 3;
bool allow_terminal = 4;
bool file_locks = 5;
repeated string empty_namespaces = 6;
string checkpoint_path = 7;
string path = 1;
map<string, string> options = 2;
}

964
api/services/snapshot/snapshots.pb.go
View File

File diff suppressed because it is too large Load Diff

47
api/services/snapshot/snapshots.proto
View File

@ -1,29 +1,41 @@
syntax = "proto3";
package containerd.v1.snapshot;
package containerd.services.snapshots.v1;
import "gogoproto/gogo.proto";
import "google/protobuf/empty.proto";
import "github.com/containerd/containerd/api/types/mount/mount.proto";
// Snapshot service manages snapshots
service Snapshot {
rpc Prepare(PrepareRequest) returns (MountsResponse);
rpc View(PrepareRequest) returns (MountsResponse);
service Snapshots {
rpc Prepare(PrepareSnapshotRequest) returns (PrepareSnapshotResponse);
rpc View(ViewSnapshotRequest) returns (ViewSnapshotResponse);
rpc Mounts(MountsRequest) returns (MountsResponse);
rpc Commit(CommitRequest) returns (google.protobuf.Empty);
rpc Remove(RemoveRequest) returns (google.protobuf.Empty);
rpc Stat(StatRequest) returns (StatResponse);
rpc List(ListRequest) returns (stream ListResponse);
rpc Commit(CommitSnapshotRequest) returns (google.protobuf.Empty);
rpc Remove(RemoveSnapshotRequest) returns (google.protobuf.Empty);
rpc Stat(StatSnapshotRequest) returns (StatSnapshotResponse);
rpc List(ListSnapshotsRequest) returns (stream ListSnapshotsResponse);
rpc Usage(UsageRequest) returns (UsageResponse);
// "Snapshot" prepares a new set of mounts from existing name
}
message PrepareRequest {
message PrepareSnapshotRequest {
string key = 1;
string parent = 2;
}
message PrepareSnapshotResponse {
repeated containerd.v1.types.Mount mounts = 1;
}
message ViewSnapshotRequest {
string key = 1;
string parent = 2;
}
message ViewSnapshotResponse {
repeated containerd.v1.types.Mount mounts = 1;
}
message MountsRequest {
string key = 1;
}
@ -32,16 +44,16 @@ message MountsResponse {
repeated containerd.v1.types.Mount mounts = 1;
}
message RemoveRequest {
message RemoveSnapshotRequest {
string key = 1;
}
message CommitRequest {
message CommitSnapshotRequest {
string name = 1;
string key = 2;
}
message StatRequest {
message StatSnapshotRequest {
string key = 1;
}
@ -61,13 +73,14 @@ message Info {
bool readonly = 4;
}
message StatResponse {
message StatSnapshotResponse {
Info info = 1 [(gogoproto.nullable) = false];
}
message ListRequest{}
message ListSnapshotsRequest{
}
message ListResponse {
message ListSnapshotsResponse {
repeated Info info = 1 [(gogoproto.nullable) = false];
}
@ -76,6 +89,6 @@ message UsageRequest {
}
message UsageResponse {
int64 inodes = 2;
int64 size = 1;
int64 inodes = 2;
}

32
api/services/version/version.pb.go
View File

@ -50,7 +50,7 @@ func (*VersionResponse) ProtoMessage() {}
func (*VersionResponse) Descriptor() ([]byte, []int) { return fileDescriptorVersion, []int{0} }
func init() {
proto.RegisterType((*VersionResponse)(nil), "containerd.v1.VersionResponse")
proto.RegisterType((*VersionResponse)(nil), "containerd.services.version.v1.VersionResponse")
}
// Reference imports to suppress errors if they are not otherwise used.
@ -77,7 +77,7 @@ func NewVersionClient(cc *grpc.ClientConn) VersionClient {
func (c *versionClient) Version(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*VersionResponse, error) {
out := new(VersionResponse)
err := grpc.Invoke(ctx, "/containerd.v1.Version/Version", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/containerd.services.version.v1.Version/Version", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
@ -104,7 +104,7 @@ func _Version_Version_Handler(srv interface{}, ctx context.Context, dec func(int
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.v1.Version/Version",
FullMethod: "/containerd.services.version.v1.Version/Version",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(VersionServer).Version(ctx, req.(*google_protobuf.Empty))
@ -113,7 +113,7 @@ func _Version_Version_Handler(srv interface{}, ctx context.Context, dec func(int
}
var _Version_serviceDesc = grpc.ServiceDesc{
ServiceName: "containerd.v1.Version",
ServiceName: "containerd.services.version.v1.Version",
HandlerType: (*VersionServer)(nil),
Methods: []grpc.MethodDesc{
{
@ -446,20 +446,20 @@ func init() {
}
var fileDescriptorVersion = []byte{
// 225 bytes of a gzipped FileDescriptorProto
// 230 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x72, 0x4e, 0xcf, 0x2c, 0xc9,
0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xce, 0xcf, 0x2b, 0x49, 0xcc, 0xcc, 0x4b, 0x2d,
0x4a, 0x41, 0x66, 0x26, 0x16, 0x64, 0xea, 0x17, 0xa7, 0x16, 0x95, 0x65, 0x26, 0xa7, 0x16, 0xeb,
0x97, 0xa5, 0x16, 0x15, 0x67, 0xe6, 0xe7, 0xc1, 0x68, 0xbd, 0x82, 0xa2, 0xfc, 0x92, 0x7c, 0x21,
0x5e, 0x84, 0x72, 0xbd, 0x32, 0x43, 0x29, 0xe9, 0xf4, 0xfc, 0xfc, 0xf4, 0x9c, 0x54, 0x7d, 0xb0,
0x64, 0x52, 0x69, 0x9a, 0x7e, 0x6a, 0x6e, 0x41, 0x49, 0x25, 0x44, 0xad, 0x94, 0x48, 0x7a, 0x7e,
0x7a, 0x3e, 0x98, 0xa9, 0x0f, 0x62, 0x41, 0x44, 0x95, 0xdc, 0xb9, 0xf8, 0xc3, 0x20, 0x46, 0x06,
0xa5, 0x16, 0x17, 0xe4, 0xe7, 0x15, 0xa7, 0x0a, 0x49, 0x70, 0xb1, 0x43, 0x6d, 0x91, 0x60, 0x54,
0x60, 0xd4, 0xe0, 0x0c, 0x82, 0x71, 0x85, 0xa4, 0xb8, 0x38, 0x8a, 0x52, 0xcb, 0x32, 0xc1, 0x52,
0x4c, 0x60, 0x29, 0x38, 0xdf, 0xc8, 0x87, 0x8b, 0x1d, 0x6a, 0x90, 0x90, 0x23, 0x82, 0x29, 0xa6,
0x07, 0x71, 0x92, 0x1e, 0xcc, 0x49, 0x7a, 0xae, 0x20, 0x27, 0x49, 0xc9, 0xe9, 0xa1, 0xb8, 0x5c,
0x0f, 0xcd, 0x0d, 0x4e, 0x12, 0x27, 0x1e, 0xca, 0x31, 0xdc, 0x78, 0x28, 0xc7, 0xd0, 0xf0, 0x48,
0x8e, 0xf1, 0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18, 0x1f, 0x3c, 0x92, 0x63, 0x4c, 0x62,
0x03, 0x9b, 0x64, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0xb4, 0x27, 0xa4, 0xd8, 0x40, 0x01, 0x00,
0x00,
0x39, 0x84, 0x72, 0x3d, 0x98, 0x52, 0x3d, 0x98, 0x92, 0x32, 0x43, 0x29, 0xe9, 0xf4, 0xfc, 0xfc,
0xf4, 0x9c, 0x54, 0x7d, 0xb0, 0xea, 0xa4, 0xd2, 0x34, 0xfd, 0xd4, 0xdc, 0x82, 0x92, 0x4a, 0x88,
0x66, 0x29, 0x91, 0xf4, 0xfc, 0xf4, 0x7c, 0x30, 0x53, 0x1f, 0xc4, 0x82, 0x88, 0x2a, 0xb9, 0x73,
0xf1, 0x87, 0x41, 0x0c, 0x08, 0x4a, 0x2d, 0x2e, 0xc8, 0xcf, 0x2b, 0x4e, 0x15, 0x92, 0xe0, 0x62,
0x87, 0x9a, 0x29, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0x19, 0x04, 0xe3, 0x0a, 0x49, 0x71, 0x71, 0x14,
0xa5, 0x96, 0x65, 0x82, 0xa5, 0x98, 0xc0, 0x52, 0x70, 0xbe, 0x51, 0x2c, 0x17, 0x3b, 0xd4, 0x20,
0xa1, 0x20, 0x04, 0x53, 0x4c, 0x0f, 0xe2, 0x24, 0x3d, 0x98, 0x93, 0xf4, 0x5c, 0x41, 0x4e, 0x92,
0xd2, 0xd7, 0xc3, 0xef, 0x15, 0x3d, 0x34, 0x47, 0x39, 0x49, 0x9c, 0x78, 0x28, 0xc7, 0x70, 0xe3,
0xa1, 0x1c, 0x43, 0xc3, 0x23, 0x39, 0xc6, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c, 0x92, 0x63, 0x7c,
0xf0, 0x48, 0x8e, 0x31, 0x89, 0x0d, 0x6c, 0xb4, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0xf3, 0x53,
0x3d, 0xea, 0x62, 0x01, 0x00, 0x00,
}

2
api/services/version/version.proto
View File

@ -1,6 +1,6 @@
syntax = "proto3";
package containerd.v1;
package containerd.services.version.v1;
import "google/protobuf/empty.proto";
import "gogoproto/gogo.proto";

363
api/types/event/container.pb.go
View File

@ -21,7 +21,7 @@
ContainerDelete
ContentDelete
Envelope
ImagePut
ImageUpdate
ImageDelete
NamespaceCreate
NamespaceUpdate
@ -63,15 +63,26 @@ var _ = math.Inf
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
type ContainerCreate struct {
ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
Image string `protobuf:"bytes,2,opt,name=image,proto3" json:"image,omitempty"`
Runtime string `protobuf:"bytes,3,opt,name=runtime,proto3" json:"runtime,omitempty"`
ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
Image string `protobuf:"bytes,2,opt,name=image,proto3" json:"image,omitempty"`
Runtime *ContainerCreate_Runtime `protobuf:"bytes,3,opt,name=runtime" json:"runtime,omitempty"`
}
func (m *ContainerCreate) Reset() { *m = ContainerCreate{} }
func (*ContainerCreate) ProtoMessage() {}
func (*ContainerCreate) Descriptor() ([]byte, []int) { return fileDescriptorContainer, []int{0} }
type ContainerCreate_Runtime struct {
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
Options map[string]string `protobuf:"bytes,2,rep,name=options" json:"options,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (m *ContainerCreate_Runtime) Reset() { *m = ContainerCreate_Runtime{} }
func (*ContainerCreate_Runtime) ProtoMessage() {}
func (*ContainerCreate_Runtime) Descriptor() ([]byte, []int) {
return fileDescriptorContainer, []int{0, 0}
}
type ContainerUpdate struct {
ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
Image string `protobuf:"bytes,2,opt,name=image,proto3" json:"image,omitempty"`
@ -93,6 +104,7 @@ func (*ContainerDelete) Descriptor() ([]byte, []int) { return fileDescriptorCont
func init() {
proto.RegisterType((*ContainerCreate)(nil), "containerd.v1.types.ContainerCreate")
proto.RegisterType((*ContainerCreate_Runtime)(nil), "containerd.v1.types.ContainerCreate.Runtime")
proto.RegisterType((*ContainerUpdate)(nil), "containerd.v1.types.ContainerUpdate")
proto.RegisterType((*ContainerDelete)(nil), "containerd.v1.types.ContainerDelete")
}
@ -123,11 +135,56 @@ func (m *ContainerCreate) MarshalTo(dAtA []byte) (int, error) {
i = encodeVarintContainer(dAtA, i, uint64(len(m.Image)))
i += copy(dAtA[i:], m.Image)
}
if len(m.Runtime) > 0 {
if m.Runtime != nil {
dAtA[i] = 0x1a
i++
i = encodeVarintContainer(dAtA, i, uint64(len(m.Runtime)))
i += copy(dAtA[i:], m.Runtime)
i = encodeVarintContainer(dAtA, i, uint64(m.Runtime.Size()))
n1, err := m.Runtime.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n1
}
return i, nil
}
func (m *ContainerCreate_Runtime) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *ContainerCreate_Runtime) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.Name) > 0 {
dAtA[i] = 0xa
i++
i = encodeVarintContainer(dAtA, i, uint64(len(m.Name)))
i += copy(dAtA[i:], m.Name)
}
if len(m.Options) > 0 {
for k, _ := range m.Options {
dAtA[i] = 0x12
i++
v := m.Options[k]
mapSize := 1 + len(k) + sovContainer(uint64(len(k))) + 1 + len(v) + sovContainer(uint64(len(v)))
i = encodeVarintContainer(dAtA, i, uint64(mapSize))
dAtA[i] = 0xa
i++
i = encodeVarintContainer(dAtA, i, uint64(len(k)))
i += copy(dAtA[i:], k)
dAtA[i] = 0x12
i++
i = encodeVarintContainer(dAtA, i, uint64(len(v)))
i += copy(dAtA[i:], v)
}
}
return i, nil
}
@ -247,10 +304,28 @@ func (m *ContainerCreate) Size() (n int) {
if l > 0 {
n += 1 + l + sovContainer(uint64(l))
}
l = len(m.Runtime)
if m.Runtime != nil {
l = m.Runtime.Size()
n += 1 + l + sovContainer(uint64(l))
}
return n
}
func (m *ContainerCreate_Runtime) Size() (n int) {
var l int
_ = l
l = len(m.Name)
if l > 0 {
n += 1 + l + sovContainer(uint64(l))
}
if len(m.Options) > 0 {
for k, v := range m.Options {
_ = k
_ = v
mapEntrySize := 1 + len(k) + sovContainer(uint64(len(k))) + 1 + len(v) + sovContainer(uint64(len(v)))
n += mapEntrySize + 1 + sovContainer(uint64(mapEntrySize))
}
}
return n
}
@ -310,7 +385,28 @@ func (this *ContainerCreate) String() string {
s := strings.Join([]string{`&ContainerCreate{`,
`ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`,
`Image:` + fmt.Sprintf("%v", this.Image) + `,`,
`Runtime:` + fmt.Sprintf("%v", this.Runtime) + `,`,
`Runtime:` + strings.Replace(fmt.Sprintf("%v", this.Runtime), "ContainerCreate_Runtime", "ContainerCreate_Runtime", 1) + `,`,
`}`,
}, "")
return s
}
func (this *ContainerCreate_Runtime) String() string {
if this == nil {
return "nil"
}
keysForOptions := make([]string, 0, len(this.Options))
for k, _ := range this.Options {
keysForOptions = append(keysForOptions, k)
}
github_com_gogo_protobuf_sortkeys.Strings(keysForOptions)
mapStringForOptions := "map[string]string{"
for _, k := range keysForOptions {
mapStringForOptions += fmt.Sprintf("%v: %v,", k, this.Options[k])
}
mapStringForOptions += "}"
s := strings.Join([]string{`&ContainerCreate_Runtime{`,
`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
`Options:` + mapStringForOptions + `,`,
`}`,
}, "")
return s
@ -447,6 +543,89 @@ func (m *ContainerCreate) Unmarshal(dAtA []byte) error {
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 ErrIntOverflowContainer
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthContainer
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Runtime == nil {
m.Runtime = &ContainerCreate_Runtime{}
}
if err := m.Runtime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipContainer(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthContainer
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *ContainerCreate_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 ErrIntOverflowContainer
}
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 {
@ -470,7 +649,123 @@ func (m *ContainerCreate) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Runtime = string(dAtA[iNdEx:postIndex])
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 ErrIntOverflowContainer
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthContainer
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
var keykey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowContainer
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
keykey |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
var stringLenmapkey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowContainer
}
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 ErrInvalidLengthContainer
}
postStringIndexmapkey := iNdEx + intStringLenmapkey
if postStringIndexmapkey > l {
return io.ErrUnexpectedEOF
}
mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
iNdEx = postStringIndexmapkey
if m.Options == nil {
m.Options = make(map[string]string)
}
if iNdEx < postIndex {
var valuekey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowContainer
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
valuekey |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
var stringLenmapvalue uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowContainer
}
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 ErrInvalidLengthContainer
}
postStringIndexmapvalue := iNdEx + intStringLenmapvalue
if postStringIndexmapvalue > l {
return io.ErrUnexpectedEOF
}
mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
iNdEx = postStringIndexmapvalue
m.Options[mapkey] = mapvalue
} else {
var mapvalue string
m.Options[mapkey] = mapvalue
}
iNdEx = postIndex
default:
iNdEx = preIndex
@ -935,26 +1230,30 @@ func init() {
}
var fileDescriptorContainer = []byte{
// 322 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x91, 0xbf, 0x4e, 0xf3, 0x30,
0x14, 0xc5, 0xeb, 0xe6, 0xfb, 0x82, 0x70, 0x90, 0x8a, 0x42, 0x07, 0xab, 0x43, 0x5a, 0x65, 0xea,
0xe4, 0x40, 0x59, 0x80, 0x09, 0xf5, 0x0f, 0xa2, 0x12, 0x53, 0x10, 0x33, 0x4a, 0x9b, 0x4b, 0xb0,
0x48, 0xe3, 0xc8, 0x75, 0x2a, 0x75, 0x63, 0xe0, 0xe1, 0x3a, 0x32, 0x32, 0x55, 0xd4, 0x4f, 0x82,
0xe2, 0xb4, 0x69, 0x84, 0x98, 0x10, 0xdb, 0xbd, 0xbe, 0xbf, 0xa3, 0x73, 0x74, 0x8c, 0xaf, 0x23,
0x26, 0x9f, 0xb3, 0x09, 0x9d, 0xf2, 0x99, 0x37, 0xe5, 0x89, 0x0c, 0x58, 0x02, 0x22, 0xac, 0x8e,
0x41, 0xca, 0x3c, 0xb9, 0x4c, 0x61, 0xee, 0xc1, 0x02, 0x12, 0xb9, 0x3f, 0xd1, 0x54, 0x70, 0xc9,
0xed, 0x93, 0x3d, 0x4b, 0x17, 0x67, 0x54, 0xa3, 0xad, 0x66, 0xc4, 0x23, 0xae, 0xef, 0x5e, 0x3e,
0x15, 0xa8, 0x9b, 0xe1, 0xc6, 0x60, 0x07, 0x0f, 0x04, 0x04, 0x12, 0xec, 0x1e, 0x3e, 0x2a, 0xf5,
0x8f, 0x2c, 0x24, 0xa8, 0x83, 0xba, 0x87, 0xfd, 0x86, 0x5a, 0xb7, 0xad, 0x12, 0x1d, 0x0f, 0x7d,
0xab, 0x84, 0xc6, 0xa1, 0xdd, 0xc4, 0xff, 0xd9, 0x2c, 0x88, 0x80, 0xd4, 0x73, 0xd8, 0x2f, 0x16,
0x9b, 0xe0, 0x03, 0x91, 0x25, 0x92, 0xcd, 0x80, 0x18, 0xfa, 0x7d, 0xb7, 0xba, 0x6f, 0xf5, 0x8a,
0xef, 0x43, 0x1a, 0xfe, 0xad, 0xef, 0x2d, 0x36, 0xe3, 0x60, 0x02, 0xf1, 0x9c, 0x18, 0x1d, 0xa3,
0x6b, 0xf5, 0x4e, 0xe9, 0x0f, 0x85, 0xd0, 0x6f, 0xfe, 0xf4, 0x4e, 0x4b, 0x46, 0x89, 0x14, 0x4b,
0x7f, 0xab, 0xb7, 0x5d, 0x6c, 0x0a, 0xce, 0xe5, 0xd3, 0x9c, 0xfc, 0xd3, 0x69, 0xb0, 0x5a, 0xb7,
0x4d, 0x9f, 0x73, 0x79, 0x73, 0xef, 0x6f, 0x2f, 0xad, 0x4b, 0x6c, 0x55, 0xa4, 0xf6, 0x31, 0x36,
0x5e, 0x60, 0x59, 0xa4, 0xf7, 0xf3, 0x31, 0x0f, 0xb9, 0x08, 0xe2, 0xac, 0x0c, 0xa9, 0x97, 0xab,
0xfa, 0x05, 0x72, 0x47, 0x95, 0x16, 0x86, 0x10, 0xc3, 0xef, 0x5a, 0xe8, 0x93, 0xd5, 0xc6, 0xa9,
0x7d, 0x6c, 0x9c, 0xda, 0xab, 0x72, 0xd0, 0x4a, 0x39, 0xe8, 0x5d, 0x39, 0xe8, 0x53, 0x39, 0x68,
0x62, 0xea, 0x5f, 0x3e, 0xff, 0x0a, 0x00, 0x00, 0xff, 0xff, 0x3f, 0xf2, 0x95, 0xd3, 0x54, 0x02,
0x00, 0x00,
// 387 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x52, 0x4f, 0x6b, 0xe2, 0x40,
0x1c, 0x75, 0x12, 0x37, 0xb2, 0x13, 0xc1, 0x65, 0xd6, 0x43, 0xc8, 0x21, 0x8a, 0x27, 0x0f, 0xcb,
0x64, 0xd7, 0xbd, 0xac, 0x9e, 0x16, 0xff, 0x51, 0xa1, 0x50, 0x18, 0xe9, 0xb9, 0x44, 0x33, 0x4d,
0x43, 0x93, 0x4c, 0x48, 0x46, 0xc1, 0x5b, 0x0f, 0xfd, 0x3c, 0xfd, 0x1c, 0x1e, 0x7b, 0xe8, 0xa1,
0x27, 0xa9, 0xf9, 0x24, 0x25, 0x93, 0x18, 0x43, 0x29, 0x05, 0x4b, 0x6f, 0xbf, 0xc9, 0x7b, 0xef,
0xf7, 0x7b, 0xef, 0x11, 0xf8, 0xdf, 0x71, 0xf9, 0xcd, 0x6a, 0x81, 0x97, 0xcc, 0x37, 0x97, 0x2c,
0xe0, 0x96, 0x1b, 0xd0, 0xc8, 0x2e, 0x8f, 0x56, 0xe8, 0x9a, 0x7c, 0x13, 0xd2, 0xd8, 0xa4, 0x6b,
0x1a, 0xf0, 0x23, 0x84, 0xc3, 0x88, 0x71, 0x86, 0x7e, 0x1e, 0xb9, 0x78, 0xfd, 0x07, 0x0b, 0xaa,
0xde, 0x74, 0x98, 0xc3, 0x04, 0x6e, 0xa6, 0x53, 0x46, 0xed, 0x3c, 0x49, 0xb0, 0x31, 0x3a, 0xb0,
0x47, 0x11, 0xb5, 0x38, 0x45, 0x3d, 0x58, 0x2f, 0x16, 0x5c, 0xb9, 0xb6, 0x06, 0xda, 0xa0, 0xfb,
0x7d, 0xd8, 0x48, 0x76, 0x2d, 0xb5, 0xa0, 0xce, 0xc6, 0x44, 0x2d, 0x48, 0x33, 0x1b, 0x35, 0xe1,
0x37, 0xd7, 0xb7, 0x1c, 0xaa, 0x49, 0x29, 0x99, 0x64, 0x0f, 0x34, 0x85, 0xb5, 0x68, 0x15, 0x70,
0xd7, 0xa7, 0x9a, 0xdc, 0x06, 0x5d, 0xb5, 0xf7, 0x0b, 0xbf, 0x63, 0x0d, 0xbf, 0x31, 0x80, 0x49,
0xa6, 0x21, 0x07, 0xb1, 0xfe, 0x00, 0x60, 0x2d, 0xff, 0x88, 0x10, 0xac, 0x06, 0x96, 0x4f, 0x33,
0x57, 0x44, 0xcc, 0x68, 0x0e, 0x6b, 0x2c, 0xe4, 0x2e, 0x0b, 0x62, 0x4d, 0x6a, 0xcb, 0x5d, 0xb5,
0xd7, 0x3f, 0xe5, 0x0e, 0xbe, 0xc8, 0xb4, 0x93, 0x80, 0x47, 0x1b, 0x72, 0xd8, 0xa4, 0x0f, 0x60,
0xbd, 0x0c, 0xa0, 0x1f, 0x50, 0xbe, 0xa5, 0x9b, 0xfc, 0x6e, 0x3a, 0xa6, 0xa1, 0xd7, 0x96, 0xb7,
0x2a, 0x42, 0x8b, 0xc7, 0x40, 0xfa, 0x07, 0x3a, 0xf7, 0xe5, 0x5a, 0x2f, 0x43, 0xfb, 0x6b, 0x6b,
0x3d, 0x83, 0x8a, 0x67, 0x2d, 0xa8, 0x17, 0x6b, 0xb2, 0x48, 0xfb, 0xfb, 0xe3, 0xb4, 0xd9, 0x7d,
0x7c, 0x2e, 0x24, 0x59, 0xc8, 0x5c, 0x8f, 0x3a, 0x50, 0x89, 0x18, 0xe3, 0xd7, 0xb1, 0x56, 0x15,
0x6e, 0x60, 0xb2, 0x6b, 0x29, 0x84, 0x31, 0x3e, 0x9d, 0x93, 0x1c, 0xd1, 0xfb, 0x50, 0x2d, 0x49,
0x4f, 0xaa, 0x61, 0x52, 0x6a, 0x61, 0x4c, 0x3d, 0xfa, 0xb9, 0x16, 0x86, 0xda, 0x76, 0x6f, 0x54,
0x9e, 0xf7, 0x46, 0xe5, 0x2e, 0x31, 0xc0, 0x36, 0x31, 0xc0, 0x63, 0x62, 0x80, 0x97, 0xc4, 0x00,
0x0b, 0x45, 0xfc, 0xc5, 0x7f, 0x5f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x47, 0x2f, 0xd1, 0x73, 0x34,
0x03, 0x00, 0x00,
}

6
api/types/event/container.proto
View File

@ -7,7 +7,11 @@ import "gogoproto/gogo.proto";
message ContainerCreate {
string container_id = 1;
string image = 2;
string runtime = 3;
message Runtime {
string name = 1;
map<string, string> options = 2;
}
Runtime runtime = 3;
}
message ContainerUpdate {

191
api/types/event/image.pb.go
View File

@ -10,6 +10,7 @@ import math "math"
import strings "strings"
import reflect "reflect"
import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
import io "io"
@ -18,14 +19,14 @@ var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type ImagePut struct {
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
Labels string `protobuf:"bytes,2,opt,name=labels,proto3" json:"labels,omitempty"`
type ImageUpdate struct {
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
Labels map[string]string `protobuf:"bytes,2,rep,name=labels" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (m *ImagePut) Reset() { *m = ImagePut{} }
func (*ImagePut) ProtoMessage() {}
func (*ImagePut) Descriptor() ([]byte, []int) { return fileDescriptorImage, []int{0} }
func (m *ImageUpdate) Reset() { *m = ImageUpdate{} }
func (*ImageUpdate) ProtoMessage() {}
func (*ImageUpdate) Descriptor() ([]byte, []int) { return fileDescriptorImage, []int{0} }
type ImageDelete struct {
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
@ -36,10 +37,10 @@ func (*ImageDelete) ProtoMessage() {}
func (*ImageDelete) Descriptor() ([]byte, []int) { return fileDescriptorImage, []int{1} }
func init() {
proto.RegisterType((*ImagePut)(nil), "containerd.v1.types.ImagePut")
proto.RegisterType((*ImageUpdate)(nil), "containerd.v1.types.ImageUpdate")
proto.RegisterType((*ImageDelete)(nil), "containerd.v1.types.ImageDelete")
}
func (m *ImagePut) Marshal() (dAtA []byte, err error) {
func (m *ImageUpdate) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
@ -49,7 +50,7 @@ func (m *ImagePut) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
func (m *ImagePut) MarshalTo(dAtA []byte) (int, error) {
func (m *ImageUpdate) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
@ -61,10 +62,21 @@ func (m *ImagePut) MarshalTo(dAtA []byte) (int, error) {
i += copy(dAtA[i:], m.Name)
}
if len(m.Labels) > 0 {
dAtA[i] = 0x12
i++
i = encodeVarintImage(dAtA, i, uint64(len(m.Labels)))
i += copy(dAtA[i:], m.Labels)
for k, _ := range m.Labels {
dAtA[i] = 0x12
i++
v := m.Labels[k]
mapSize := 1 + len(k) + sovImage(uint64(len(k))) + 1 + len(v) + sovImage(uint64(len(v)))
i = encodeVarintImage(dAtA, i, uint64(mapSize))
dAtA[i] = 0xa
i++
i = encodeVarintImage(dAtA, i, uint64(len(k)))
i += copy(dAtA[i:], k)
dAtA[i] = 0x12
i++
i = encodeVarintImage(dAtA, i, uint64(len(v)))
i += copy(dAtA[i:], v)
}
}
return i, nil
}
@ -120,16 +132,20 @@ func encodeVarintImage(dAtA []byte, offset int, v uint64) int {
dAtA[offset] = uint8(v)
return offset + 1
}
func (m *ImagePut) Size() (n int) {
func (m *ImageUpdate) Size() (n int) {
var l int
_ = l
l = len(m.Name)
if l > 0 {
n += 1 + l + sovImage(uint64(l))
}
l = len(m.Labels)
if l > 0 {
n += 1 + l + sovImage(uint64(l))
if len(m.Labels) > 0 {
for k, v := range m.Labels {
_ = k
_ = v
mapEntrySize := 1 + len(k) + sovImage(uint64(len(k))) + 1 + len(v) + sovImage(uint64(len(v)))
n += mapEntrySize + 1 + sovImage(uint64(mapEntrySize))
}
}
return n
}
@ -157,13 +173,23 @@ func sovImage(x uint64) (n int) {
func sozImage(x uint64) (n int) {
return sovImage(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *ImagePut) String() string {
func (this *ImageUpdate) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&ImagePut{`,
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 += "}"
s := strings.Join([]string{`&ImageUpdate{`,
`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
`Labels:` + fmt.Sprintf("%v", this.Labels) + `,`,
`Labels:` + mapStringForLabels + `,`,
`}`,
}, "")
return s
@ -186,7 +212,7 @@ func valueToStringImage(v interface{}) string {
pv := reflect.Indirect(rv).Interface()
return fmt.Sprintf("*%v", pv)
}
func (m *ImagePut) Unmarshal(dAtA []byte) error {
func (m *ImageUpdate) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@ -209,10 +235,10 @@ func (m *ImagePut) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: ImagePut: wiretype end group for non-group")
return fmt.Errorf("proto: ImageUpdate: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: ImagePut: illegal tag %d (wire type %d)", fieldNum, wire)
return fmt.Errorf("proto: ImageUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
@ -248,7 +274,7 @@ func (m *ImagePut) Unmarshal(dAtA []byte) error {
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
}
var stringLen uint64
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowImage
@ -258,20 +284,107 @@ func (m *ImagePut) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
if msglen < 0 {
return ErrInvalidLengthImage
}
postIndex := iNdEx + intStringLen
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Labels = string(dAtA[iNdEx:postIndex])
var keykey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowImage
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
keykey |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
var stringLenmapkey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowImage
}
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 ErrInvalidLengthImage
}
postStringIndexmapkey := iNdEx + intStringLenmapkey
if postStringIndexmapkey > l {
return io.ErrUnexpectedEOF
}
mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
iNdEx = postStringIndexmapkey
if m.Labels == nil {
m.Labels = make(map[string]string)
}
if iNdEx < postIndex {
var valuekey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowImage
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
valuekey |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
var stringLenmapvalue uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowImage
}
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 ErrInvalidLengthImage
}
postStringIndexmapvalue := iNdEx + intStringLenmapvalue
if postStringIndexmapvalue > l {
return io.ErrUnexpectedEOF
}
mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
iNdEx = postStringIndexmapvalue
m.Labels[mapkey] = mapvalue
} else {
var mapvalue string
m.Labels[mapkey] = mapvalue
}
iNdEx = postIndex
default:
iNdEx = preIndex
@ -483,16 +596,20 @@ func init() {
}
var fileDescriptorImage = []byte{
// 175 bytes of a gzipped FileDescriptorProto
// 232 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xb2, 0x49, 0xcf, 0x2c, 0xc9,
0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xce, 0xcf, 0x2b, 0x49, 0xcc, 0xcc, 0x4b, 0x2d,
0x4a, 0x41, 0x66, 0x26, 0x16, 0x64, 0xea, 0x97, 0x54, 0x16, 0xa4, 0x16, 0xeb, 0xa7, 0x96, 0xa5,
0xe6, 0x95, 0xe8, 0x67, 0xe6, 0x26, 0xa6, 0xa7, 0xea, 0x15, 0x14, 0xe5, 0x97, 0xe4, 0x0b, 0x09,
0x23, 0xd4, 0xe9, 0x95, 0x19, 0xea, 0x81, 0x95, 0x29, 0x99, 0x71, 0x71, 0x78, 0x82, 0xd4, 0x04,
0x94, 0x96, 0x08, 0x09, 0x71, 0xb1, 0xe4, 0x25, 0xe6, 0xa6, 0x4a, 0x30, 0x2a, 0x30, 0x6a, 0x70,
0x06, 0x81, 0xd9, 0x42, 0x62, 0x5c, 0x6c, 0x39, 0x89, 0x49, 0xa9, 0x39, 0xc5, 0x12, 0x4c, 0x60,
0x51, 0x28, 0x4f, 0x49, 0x91, 0x8b, 0x1b, 0xac, 0xcf, 0x25, 0x35, 0x27, 0xb5, 0x24, 0x15, 0x9b,
0x56, 0x27, 0x89, 0x13, 0x0f, 0xe5, 0x18, 0x6e, 0x3c, 0x94, 0x63, 0x68, 0x78, 0x24, 0xc7, 0x78,
0xe2, 0x91, 0x1c, 0xe3, 0x85, 0x47, 0x72, 0x8c, 0x0f, 0x1e, 0xc9, 0x31, 0x26, 0xb1, 0x81, 0x1d,
0x64, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0xfa, 0x87, 0x34, 0x3a, 0xd0, 0x00, 0x00, 0x00,
0x23, 0xd4, 0xe9, 0x95, 0x19, 0xea, 0x81, 0x95, 0x29, 0x2d, 0x62, 0xe4, 0xe2, 0xf6, 0x04, 0x29,
0x0a, 0x2d, 0x48, 0x49, 0x2c, 0x49, 0x15, 0x12, 0xe2, 0x62, 0xc9, 0x4b, 0xcc, 0x4d, 0x95, 0x60,
0x54, 0x60, 0xd4, 0xe0, 0x0c, 0x02, 0xb3, 0x85, 0x5c, 0xb8, 0xd8, 0x72, 0x12, 0x93, 0x52, 0x73,
0x8a, 0x25, 0x98, 0x14, 0x98, 0x35, 0xb8, 0x8d, 0x74, 0xf4, 0xb0, 0x98, 0xa4, 0x87, 0x64, 0x8a,
0x9e, 0x0f, 0x58, 0xb9, 0x6b, 0x5e, 0x49, 0x51, 0x65, 0x10, 0x54, 0xaf, 0x94, 0x25, 0x17, 0x37,
0x92, 0xb0, 0x90, 0x00, 0x17, 0x73, 0x76, 0x6a, 0x25, 0xd4, 0x1e, 0x10, 0x53, 0x48, 0x84, 0x8b,
0xb5, 0x2c, 0x31, 0xa7, 0x34, 0x55, 0x82, 0x09, 0x2c, 0x06, 0xe1, 0x58, 0x31, 0x59, 0x30, 0x2a,
0x29, 0x42, 0xdd, 0xe8, 0x92, 0x9a, 0x93, 0x8a, 0xdd, 0x8d, 0x4e, 0x12, 0x27, 0x1e, 0xca, 0x31,
0xdc, 0x78, 0x28, 0xc7, 0xd0, 0xf0, 0x48, 0x8e, 0xf1, 0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4,
0x18, 0x1f, 0x3c, 0x92, 0x63, 0x4c, 0x62, 0x03, 0xfb, 0xde, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff,
0xa7, 0x64, 0x49, 0x13, 0x3d, 0x01, 0x00, 0x00,
}

4
api/types/event/image.proto
View File

@ -2,9 +2,9 @@ syntax = "proto3";
package containerd.v1.types;
message ImagePut {
message ImageUpdate {
string name = 1;
string labels = 2;
map<string, string> labels = 2;
}
message ImageDelete {

71
api/types/event/task.pb.go
View File

@ -36,6 +36,8 @@ func (*TaskStart) Descriptor() ([]byte, []int) { return fileDescriptorTask, []in
type TaskDelete struct {
ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
Pid uint32 `protobuf:"varint,2,opt,name=pid,proto3" json:"pid,omitempty"`
ExitStatus uint32 `protobuf:"varint,3,opt,name=exit_status,json=exitStatus,proto3" json:"exit_status,omitempty"`
}
func (m *TaskDelete) Reset() { *m = TaskDelete{} }
@ -116,6 +118,16 @@ func (m *TaskDelete) MarshalTo(dAtA []byte) (int, error) {
i = encodeVarintTask(dAtA, i, uint64(len(m.ContainerID)))
i += copy(dAtA[i:], m.ContainerID)
}
if m.Pid != 0 {
dAtA[i] = 0x10
i++
i = encodeVarintTask(dAtA, i, uint64(m.Pid))
}
if m.ExitStatus != 0 {
dAtA[i] = 0x18
i++
i = encodeVarintTask(dAtA, i, uint64(m.ExitStatus))
}
return i, nil
}
@ -173,6 +185,12 @@ func (m *TaskDelete) Size() (n int) {
if l > 0 {
n += 1 + l + sovTask(uint64(l))
}
if m.Pid != 0 {
n += 1 + sovTask(uint64(m.Pid))
}
if m.ExitStatus != 0 {
n += 1 + sovTask(uint64(m.ExitStatus))
}
return n
}
@ -215,6 +233,8 @@ func (this *TaskDelete) String() string {
}
s := strings.Join([]string{`&TaskDelete{`,
`ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`,
`Pid:` + fmt.Sprintf("%v", this.Pid) + `,`,
`ExitStatus:` + fmt.Sprintf("%v", this.ExitStatus) + `,`,
`}`,
}, "")
return s
@ -443,6 +463,44 @@ func (m *TaskDelete) Unmarshal(dAtA []byte) error {
}
m.ContainerID = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType)
}
m.Pid = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTask
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Pid |= (uint32(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 3:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field ExitStatus", wireType)
}
m.ExitStatus = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTask
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.ExitStatus |= (uint32(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipTask(dAtA[iNdEx:])
@ -574,7 +632,7 @@ func init() {
}
var fileDescriptorTask = []byte{
// 186 bytes of a gzipped FileDescriptorProto
// 228 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xb2, 0x4e, 0xcf, 0x2c, 0xc9,
0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xce, 0xcf, 0x2b, 0x49, 0xcc, 0xcc, 0x4b, 0x2d,
0x4a, 0x41, 0x66, 0x26, 0x16, 0x64, 0xea, 0x97, 0x54, 0x16, 0xa4, 0x16, 0xeb, 0xa7, 0x96, 0xa5,
@ -583,8 +641,11 @@ var fileDescriptorTask = []byte{
0x17, 0xa5, 0x26, 0x96, 0xa4, 0x0a, 0x19, 0x71, 0xf1, 0xc0, 0x15, 0xc5, 0x67, 0xa6, 0x48, 0x30,
0x2a, 0x30, 0x6a, 0x70, 0x3a, 0xf1, 0x3f, 0xba, 0x27, 0xcf, 0xed, 0x0c, 0x13, 0xf7, 0x74, 0x09,
0xe2, 0x86, 0x2b, 0xf2, 0x4c, 0x51, 0xb2, 0xe7, 0xe2, 0x04, 0x99, 0x10, 0x5c, 0x92, 0x58, 0x54,
0x42, 0x96, 0x01, 0x50, 0x27, 0xb8, 0xa4, 0xe6, 0xa4, 0x92, 0xe7, 0x04, 0x27, 0x89, 0x13, 0x0f,
0xe5, 0x18, 0x6e, 0x3c, 0x94, 0x63, 0x68, 0x78, 0x24, 0xc7, 0x78, 0xe2, 0x91, 0x1c, 0xe3, 0x85,
0x47, 0x72, 0x8c, 0x0f, 0x1e, 0xc9, 0x31, 0x26, 0xb1, 0x81, 0xbd, 0x6e, 0x0c, 0x08, 0x00, 0x00,
0xff, 0xff, 0x3a, 0x4d, 0xa1, 0xee, 0x39, 0x01, 0x00, 0x00,
0x42, 0x96, 0x01, 0xc5, 0x10, 0x27, 0xb8, 0xa4, 0xe6, 0xa4, 0x92, 0xe7, 0x04, 0x21, 0x01, 0x2e,
0xe6, 0x82, 0xcc, 0x14, 0x09, 0x26, 0x05, 0x46, 0x0d, 0xde, 0x20, 0x10, 0x53, 0x48, 0x9e, 0x8b,
0x3b, 0xb5, 0x22, 0xb3, 0x24, 0xbe, 0xb8, 0x24, 0xb1, 0xa4, 0xb4, 0x58, 0x82, 0x19, 0x2c, 0xc3,
0x05, 0x12, 0x0a, 0x06, 0x8b, 0x38, 0x49, 0x9c, 0x78, 0x28, 0xc7, 0x70, 0xe3, 0xa1, 0x1c, 0x43,
0xc3, 0x23, 0x39, 0xc6, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c, 0x92, 0x63, 0x7c, 0xf0, 0x48, 0x8e,
0x31, 0x89, 0x0d, 0x1c, 0x5a, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x0e, 0x43, 0xc1, 0x0e,
0x6c, 0x01, 0x00, 0x00,
}

2
api/types/event/task.proto
View File

@ -12,4 +12,6 @@ message TaskStart {
message TaskDelete {
string container_id = 1;
uint32 pid = 2;
uint32 exit_status = 3;
}

19
client.go
View File

@ -13,6 +13,7 @@ import (
"github.com/containerd/containerd/api/services/containers"
contentapi "github.com/containerd/containerd/api/services/content"
diffapi "github.com/containerd/containerd/api/services/diff"
eventsapi "github.com/containerd/containerd/api/services/events"
"github.com/containerd/containerd/api/services/execution"
imagesapi "github.com/containerd/containerd/api/services/images"
namespacesapi "github.com/containerd/containerd/api/services/namespaces"
@ -180,7 +181,9 @@ func WithNewReadonlyRootFS(id string, i Image) NewContainerOpts {
func WithRuntime(name string) NewContainerOpts {
return func(ctx context.Context, client *Client, c *containers.Container) error {
c.Runtime = name
c.Runtime = &containers.Container_Runtime{
Name: name,
}
return nil
}
}
@ -196,8 +199,10 @@ func WithImage(i Image) NewContainerOpts {
// the id must be unique within the namespace
func (c *Client) NewContainer(ctx context.Context, id string, opts ...NewContainerOpts) (Container, error) {
container := containers.Container{
ID: id,
Runtime: c.runtime,
ID: id,
Runtime: &containers.Container_Runtime{
Name: c.runtime,
},
}
for _, o := range opts {
if err := o(ctx, c, &container); err != nil {
@ -331,7 +336,7 @@ func (c *Client) Pull(ctx context.Context, ref string, opts ...RemoteOpts) (Imag
}
is := c.ImageService()
if err := is.Put(ctx, name, desc); err != nil {
if err := is.Update(ctx, name, desc); err != nil {
return nil, err
}
i, err := is.Get(ctx, name)
@ -448,7 +453,7 @@ func (c *Client) ContentStore() content.Store {
}
func (c *Client) SnapshotService() snapshot.Snapshotter {
return snapshotservice.NewSnapshotterFromClient(snapshotapi.NewSnapshotClient(c.conn))
return snapshotservice.NewSnapshotterFromClient(snapshotapi.NewSnapshotsClient(c.conn))
}
func (c *Client) TaskService() execution.TasksClient {
@ -467,6 +472,10 @@ func (c *Client) HealthService() grpc_health_v1.HealthClient {
return grpc_health_v1.NewHealthClient(c.conn)
}
func (c *Client) EventService() eventsapi.EventsClient {
return eventsapi.NewEventsClient(c.conn)
}
func (c *Client) VersionService() versionservice.VersionClient {
return versionservice.NewVersionClient(c.conn)
}

3
client_test.go
View File

@ -27,7 +27,7 @@ var (
)
func init() {
flag.StringVar(&address, "address", "/run/containerd/containerd.sock", "The address to the containerd socket for use in the tests")
flag.StringVar(&address, "address", "/run/containerd-test/containerd.sock", "The address to the containerd socket for use in the tests")
flag.BoolVar(&noDaemon, "no-daemon", false, "Do not start a dedicated daemon for the tests")
flag.Parse()
}
@ -59,6 +59,7 @@ func TestMain(m *testing.M) {
cmd = exec.Command("containerd",
"--root", defaultRoot,
"--state", defaultState,
"--address", address,
)
cmd.Stderr = buf
if err := cmd.Start(); err != nil {

2
cmd/containerd/main.go
View File

@ -323,7 +323,7 @@ func interceptor(ctx gocontext.Context,
// No need to change the context
case versionapi.VersionServer:
ctx = log.WithModule(ctx, "version")
case snapshotapi.SnapshotServer:
case snapshotapi.SnapshotsServer:
ctx = log.WithModule(ctx, "snapshot")
case diffapi.DiffServer:
ctx = log.WithModule(ctx, "diff")

8
cmd/ctr/events.go
View File

@ -23,7 +23,7 @@ var eventsCommand = cli.Command{
ctx, cancel := appContext(context)
defer cancel()
events, err := eventsClient.EventStream(ctx, &eventsapi.EventStreamRequest{})
events, err := eventsClient.Stream(ctx, &eventsapi.StreamEventsRequest{})
if err != nil {
return err
}
@ -83,7 +83,7 @@ func getEventOutput(evt *event.Envelope) (string, error) {
if err := proto.Unmarshal(evt.Event.Value, e); err != nil {
return out, err
}
out = "id=" + e.ContainerID
out = fmt.Sprintf("id=%s pid=%d status=%d", e.ContainerID, e.Pid, e.ExitStatus)
case "types.containerd.io/containerd.v1.types.event.ContainerUpdate":
e := &event.ContainerUpdate{}
if err := proto.Unmarshal(evt.Event.Value, e); err != nil {
@ -114,8 +114,8 @@ func getEventOutput(evt *event.Envelope) (string, error) {
return out, err
}
out = "key=" + e.Key
case "types.containerd.io/containerd.v1.types.event.ImagePut":
e := &event.ImagePut{}
case "types.containerd.io/containerd.v1.types.event.ImageUpdate":
e := &event.ImageUpdate{}
if err := proto.Unmarshal(evt.Event.Value, e); err != nil {
return out, err
}

10
cmd/ctr/run_windows.go
View File

@ -150,16 +150,18 @@ func newCreateContainerRequest(context *cli.Context, id, snapshot, image string,
TypeUrl: specs.Version,
Value: spec,
},
Runtime: context.String("runtime"),
RootFS: snapshot,
Runtime: &containersapi.Container_Runtime{
Name: context.String("runtime"),
},
RootFS: snapshot,
},
}
return create, nil
}
func newCreateTaskRequest(context *cli.Context, id, tmpDir string, checkpoint *ocispec.Descriptor, mounts []mount.Mount) (*execution.CreateRequest, error) {
create := &execution.CreateRequest{
func newCreateTaskRequest(context *cli.Context, id, tmpDir string, checkpoint *ocispec.Descriptor, mounts []mount.Mount) (*execution.CreateTaskRequest, error) {
create := &execution.CreateTaskRequest{
ContainerID: id,
Terminal: context.Bool("tty"),
Stdin: fmt.Sprintf(`%s\ctr-%s-stdin`, pipeRoot, id),

18
cmd/ctr/utils.go
View File

@ -21,7 +21,6 @@ import (
namespacesapi "github.com/containerd/containerd/api/services/namespaces"
snapshotapi "github.com/containerd/containerd/api/services/snapshot"
versionservice "github.com/containerd/containerd/api/services/version"
"github.com/containerd/containerd/api/types/task"
"github.com/containerd/containerd/content"
"github.com/containerd/containerd/images"
"github.com/containerd/containerd/namespaces"
@ -112,7 +111,7 @@ func getSnapshotter(context *cli.Context) (snapshot.Snapshotter, error) {
if err != nil {
return nil, err
}
return snapshotservice.NewSnapshotterFromClient(snapshotapi.NewSnapshotClient(conn)), nil
return snapshotservice.NewSnapshotterFromClient(snapshotapi.NewSnapshotsClient(conn)), nil
}
func getImageStore(clicontext *cli.Context) (images.Store, error) {
@ -139,21 +138,6 @@ func getVersionService(context *cli.Context) (versionservice.VersionClient, erro
return versionservice.NewVersionClient(conn), nil
}
func waitContainer(events execution.Tasks_EventsClient, id string, pid uint32) (uint32, error) {
for {
e, err := events.Recv()
if err != nil {
return 255, err
}
if e.Type != task.Event_EXIT {
continue
}
if e.ID == id && e.Pid == pid {
return e.ExitStatus, nil
}
}
}
func forwardAllSignals(ctx gocontext.Context, task killer) chan os.Signal {
sigc := make(chan os.Signal, 128)
signal.Notify(sigc)

1
cmd/dist/rootfs.go vendored
View File

@ -99,7 +99,6 @@ var rootfsPrepareCommand = cli.Command{
}
snapshotter := client.SnapshotService()
mounts, err := snapshotter.Prepare(ctx, target, dgst.String())
if err != nil {
return err

6
container.go
View File

@ -104,7 +104,7 @@ func (c *container) Image(ctx context.Context) (Image, error) {
}, nil
}
type NewTaskOpts func(context.Context, *Client, *execution.CreateRequest) error
type NewTaskOpts func(context.Context, *Client, *execution.CreateTaskRequest) error
func (c *container) NewTask(ctx context.Context, ioCreate IOCreation, opts ...NewTaskOpts) (Task, error) {
c.mu.Lock()
@ -113,7 +113,7 @@ func (c *container) NewTask(ctx context.Context, ioCreate IOCreation, opts ...Ne
if err != nil {
return nil, err
}
request := &execution.CreateRequest{
request := &execution.CreateTaskRequest{
ContainerID: c.c.ID,
Terminal: i.Terminal,
Stdin: i.Stdin,
@ -161,7 +161,7 @@ func (c *container) NewTask(ctx context.Context, ioCreate IOCreation, opts ...Ne
}
func (c *container) loadTask(ctx context.Context, ioAttach IOAttach) (Task, error) {
response, err := c.client.TaskService().Info(ctx, &execution.InfoRequest{
response, err := c.client.TaskService().Get(ctx, &execution.GetTaskRequest{
ContainerID: c.c.ID,
})
if err != nil {

6
container_test.go
View File

@ -389,7 +389,7 @@ func TestContainerProcesses(t *testing.T) {
<-statusC
}
func TestContainerCloseStdin(t *testing.T) {
func TestContainerCloseIO(t *testing.T) {
if testing.Short() {
t.Skip()
}
@ -456,7 +456,7 @@ func TestContainerCloseStdin(t *testing.T) {
t.Error(err)
}
w.Close()
if err := task.CloseStdin(ctx); err != nil {
if err := task.CloseIO(ctx, WithStdinCloser); err != nil {
t.Error(err)
}
@ -576,7 +576,7 @@ func TestContainerAttach(t *testing.T) {
}
w.Close()
if err := task.CloseStdin(ctx); err != nil {
if err := task.CloseIO(ctx, WithStdinCloser); err != nil {
t.Error(err)
}

2
container_unix.go
View File

@ -83,7 +83,7 @@ func WithCheckpoint(desc v1.Descriptor, rootfsID string) NewContainerOpts {
}
func WithTaskCheckpoint(desc v1.Descriptor) NewTaskOpts {
return func(ctx context.Context, c *Client, r *execution.CreateRequest) error {
return func(ctx context.Context, c *Client, r *execution.CreateTaskRequest) error {
id := desc.Digest
index, err := decodeIndex(ctx, c.ContentStore(), id)
if err != nil {

43
containers/containers.go
View File

@ -1,7 +1,10 @@
package containers
import (
"bytes"
"context"
"encoding/gob"
"errors"
"time"
)
@ -13,13 +16,51 @@ type Container struct {
ID string
Labels map[string]string
Image string
Runtime string
Runtime RuntimeInfo
Spec []byte
RootFS string
CreatedAt time.Time
UpdatedAt time.Time
}
type RuntimeInfo struct {
Name string
Options map[string]string
}
type marshaledRuntimeInfo struct {
Name string
Options map[string]string
}
func (r *RuntimeInfo) MarshalBinary() ([]byte, error) {
buf := bytes.NewBuffer(nil)
if err := gob.NewEncoder(buf).Encode(marshaledRuntimeInfo{
Name: r.Name,
Options: r.Options,
}); err != nil {
return nil, err
}
return buf.Bytes(), nil
}
func (r *RuntimeInfo) UnmarshalBinary(data []byte) error {
buf := data
if len(buf) == 0 {
return errors.New("RuntimeInfo: no data")
}
var (
mr marshaledRuntimeInfo
reader = bytes.NewReader(buf)
)
if err := gob.NewDecoder(reader).Decode(&mr); err != nil {
return err
}
r.Name = mr.Name
r.Options = mr.Options
return nil
}
type Store interface {
Get(ctx context.Context, id string) (Container, error)
List(ctx context.Context, filter string) ([]Container, error)

4
events/convert.go
View File

@ -52,8 +52,8 @@ func convertToAny(evt Event) (*protobuf.Any, error) {
case event.SnapshotRemove:
url = getUrl("SnapshotRemove")
pb = &v
case event.ImagePut:
url = getUrl("ImagePut")
case event.ImageUpdate:
url = getUrl("ImageUpdate")
pb = &v
case event.ImageDelete:
url = getUrl("ImageDelete")

2
images/image.go
View File

@ -18,7 +18,7 @@ type Image struct {
}
type Store interface {
Put(ctx context.Context, name string, desc ocispec.Descriptor) error
Update(ctx context.Context, name string, desc ocispec.Descriptor) error
Get(ctx context.Context, name string) (Image, error)
List(ctx context.Context) ([]Image, error)
Delete(ctx context.Context, name string) error

6
linux/runtime.go
View File

@ -298,10 +298,10 @@ func (r *Runtime) Delete(ctx context.Context, c plugin.Task) (*plugin.Exit, erro
}); err != nil {
return nil, err
}
return &plugin.Exit{
Status: rsp.ExitStatus,
Timestamp: rsp.ExitedAt,
Pid: rsp.Pid,
}, r.deleteBundle(namespace, lc.containerID)
}
@ -370,10 +370,6 @@ func (r *Runtime) loadTasks(ctx context.Context, ns string) ([]*Task, error) {
return o, nil
}
func (r *Runtime) Events(ctx context.Context) <-chan *plugin.Event {
return r.events
}
func (r *Runtime) handleEvents(ctx context.Context, s shim.ShimClient) error {
events, err := s.Events(r.eventsContext, &shim.EventsRequest{})
if err != nil {

25
linux/shim/init.go
View File

@ -254,19 +254,24 @@ func (p *initProcess) Stdin() io.Closer {
func (p *initProcess) Checkpoint(context context.Context, r *shimapi.CheckpointRequest) error {
var actions []runc.CheckpointAction
if !r.Exit {
actions = append(actions, runc.LeaveRunning)
}
/*
if !r.Exit {
actions = append(actions, runc.LeaveRunning)
}
*/
work := filepath.Join(p.bundle, "work")
defer os.RemoveAll(work)
// TODO: convert options into runc flags or a better format for criu
if err := p.runc.Checkpoint(context, p.id, &runc.CheckpointOpts{
WorkDir: work,
ImagePath: r.CheckpointPath,
AllowOpenTCP: r.AllowTcp,
AllowExternalUnixSockets: r.AllowUnixSockets,
AllowTerminal: r.AllowTerminal,
FileLocks: r.FileLocks,
EmptyNamespaces: r.EmptyNamespaces,
WorkDir: work,
ImagePath: r.Path,
/*
AllowOpenTCP: r.AllowTcp,
AllowExternalUnixSockets: r.AllowUnixSockets,
AllowTerminal: r.AllowTerminal,
FileLocks: r.FileLocks,
EmptyNamespaces: r.EmptyNamespaces,
*/
}, actions...); err != nil {
dumpLog := filepath.Join(p.bundle, "criu-dump.log")
if cerr := copyFile(dumpLog, filepath.Join(work, "dump.log")); cerr != nil {

2
linux/shim/service.go
View File

@ -98,6 +98,7 @@ func (s *Service) Delete(ctx context.Context, r *shimapi.DeleteRequest) (*shimap
return &shimapi.DeleteResponse{
ExitStatus: uint32(p.Status()),
ExitedAt: p.ExitedAt(),
Pid: uint32(p.Pid()),
}, nil
}
@ -119,6 +120,7 @@ func (s *Service) DeleteProcess(ctx context.Context, r *shimapi.DeleteProcessReq
return &shimapi.DeleteResponse{
ExitStatus: uint32(p.Status()),
ExitedAt: p.ExitedAt(),
Pid: uint32(p.Pid()),
}, nil
}

22
linux/task.go
View File

@ -165,20 +165,15 @@ func (t *Task) CloseStdin(ctx context.Context, pid uint32) error {
return err
}
func (t *Task) Checkpoint(ctx context.Context, opts plugin.CheckpointOpts) error {
_, err := t.shim.Checkpoint(ctx, &shim.CheckpointRequest{
Exit: opts.Exit,
AllowTcp: opts.AllowTCP,
AllowUnixSockets: opts.AllowUnixSockets,
AllowTerminal: opts.AllowTerminal,
FileLocks: opts.FileLocks,
EmptyNamespaces: opts.EmptyNamespaces,
CheckpointPath: opts.Path,
})
if err != nil {
err = errors.New(grpc.ErrorDesc(err))
func (t *Task) Checkpoint(ctx context.Context, path string, options map[string]string) error {
r := &shim.CheckpointRequest{
Path: path,
Options: options,
}
return err
if _, err := t.shim.Checkpoint(ctx, r); err != nil {
return errors.New(grpc.ErrorDesc(err))
}
return nil
}
func (t *Task) DeleteProcess(ctx context.Context, pid uint32) (*plugin.Exit, error) {
@ -191,6 +186,7 @@ func (t *Task) DeleteProcess(ctx context.Context, pid uint32) (*plugin.Exit, err
return &plugin.Exit{
Status: r.ExitStatus,
Timestamp: r.ExitedAt,
Pid: pid,
}, nil
}

10
metadata/containers.go
View File

@ -146,7 +146,9 @@ func readContainer(container *containers.Container, bkt *bolt.Bucket) error {
case string(bucketKeyImage):
container.Image = string(v)
case string(bucketKeyRuntime):
container.Runtime = string(v)
if err := container.Runtime.UnmarshalBinary(v); err != nil {
return err
}
case string(bucketKeySpec):
container.Spec = make([]byte, len(v))
copy(container.Spec, v)
@ -187,9 +189,13 @@ func writeContainer(container *containers.Container, bkt *bolt.Bucket) error {
if err != nil {
return err
}
runtime, err := container.Runtime.MarshalBinary()
if err != nil {
return err
}
for _, v := range [][2][]byte{
{bucketKeyImage, []byte(container.Image)},
{bucketKeyRuntime, []byte(container.Runtime)},
{bucketKeyRuntime, runtime},
{bucketKeySpec, container.Spec},
{bucketKeyRootFS, []byte(container.RootFS)},
{bucketKeyCreatedAt, createdAt},

2
metadata/images.go
View File

@ -46,7 +46,7 @@ func (s *imageStore) Get(ctx context.Context, name string) (images.Image, error)
return image, nil
}
func (s *imageStore) Put(ctx context.Context, name string, desc ocispec.Descriptor) error {
func (s *imageStore) Update(ctx context.Context, name string, desc ocispec.Descriptor) error {
namespace, err := namespaces.NamespaceRequired(ctx)
if err != nil {
return err

12
plugin/container.go
View File

@ -32,21 +32,11 @@ type Task interface {
// CloseStdin closes the processes stdin
CloseStdin(context.Context, uint32) error
// Checkpoint checkpoints a container to an image with live system data
Checkpoint(context.Context, CheckpointOpts) error
Checkpoint(context.Context, string, map[string]string) error
// DeleteProcess deletes a specific exec process via the pid
DeleteProcess(context.Context, uint32) (*Exit, error)
}
type CheckpointOpts struct {
Exit bool
AllowTCP bool
AllowUnixSockets bool
AllowTerminal bool
FileLocks bool
EmptyNamespaces []string
Path string
}
type ExecOpts struct {
Spec []byte
IO IO

3
plugin/runtime.go
View File

@ -25,6 +25,7 @@ type CreateOpts struct {
}
type Exit struct {
Pid uint32
Status uint32
Timestamp time.Time
}
@ -43,6 +44,4 @@ type Runtime interface {
Tasks(context.Context) ([]Task, error)
// Delete removes the task in the runtime.
Delete(context.Context, Task) (*Exit, error)
// Events returns events for the runtime and all tasks created by the runtime
Events(context.Context) <-chan *Event
}

42
process.go
View File

@ -5,8 +5,11 @@ import (
"encoding/json"
"syscall"
eventsapi "github.com/containerd/containerd/api/services/events"
"github.com/containerd/containerd/api/services/execution"
taskapi "github.com/containerd/containerd/api/types/task"
"github.com/containerd/containerd/api/types/event"
tasktypes "github.com/containerd/containerd/api/types/task"
"github.com/gogo/protobuf/proto"
protobuf "github.com/gogo/protobuf/types"
specs "github.com/opencontainers/runtime-spec/specs-go"
)
@ -38,7 +41,7 @@ func (p *process) Start(ctx context.Context) error {
if err != nil {
return err
}
request := &execution.ExecRequest{
request := &execution.ExecProcessRequest{
ContainerID: p.task.containerID,
Terminal: p.io.Terminal,
Stdin: p.io.Stdin,
@ -70,30 +73,43 @@ func (p *process) Kill(ctx context.Context, s syscall.Signal) error {
}
func (p *process) Wait(ctx context.Context) (uint32, error) {
events, err := p.task.client.TaskService().Events(ctx, &execution.EventsRequest{})
// TODO (ehazlett): add filtering for specific event
events, err := p.task.client.EventService().Stream(ctx, &eventsapi.StreamEventsRequest{})
if err != nil {
return UnknownExitStatus, err
}
<-p.pidSync
for {
e, err := events.Recv()
evt, err := events.Recv()
if err != nil {
return UnknownExitStatus, err
}
if e.Type != taskapi.Event_EXIT {
continue
}
if e.ID == p.task.containerID && e.Pid == p.pid {
return e.ExitStatus, nil
if evt.Event.TypeUrl == "types.containerd.io/containerd.v1.types.event.RuntimeEvent" {
e := &event.RuntimeEvent{}
if err := proto.Unmarshal(evt.Event.Value, e); err != nil {
return UnknownExitStatus, err
}
if e.Type != tasktypes.Event_EXIT {
continue
}
if e.ID == p.task.containerID && e.Pid == p.pid {
return e.ExitStatus, nil
}
}
}
}
func (p *process) CloseStdin(ctx context.Context) error {
_, err := p.task.client.TaskService().CloseStdin(ctx, &execution.CloseStdinRequest{
func (p *process) CloseIO(ctx context.Context, opts ...IOCloserOpts) error {
r := &execution.CloseIORequest{
ContainerID: p.task.containerID,
Pid: p.pid,
})
}
for _, o := range opts {
o(r)
}
_, err := p.task.client.TaskService().CloseIO(ctx, r)
return err
}
@ -102,7 +118,7 @@ func (p *process) IO() *IO {
}
func (p *process) Resize(ctx context.Context, w, h uint32) error {
_, err := p.task.client.TaskService().Pty(ctx, &execution.PtyRequest{
_, err := p.task.client.TaskService().ResizePty(ctx, &execution.ResizePtyRequest{
ContainerID: p.task.containerID,
Width: w,
Height: h,

26
services/containers/helpers.go
View File

@ -22,10 +22,13 @@ func containersToProto(containers []containers.Container) []api.Container {
func containerToProto(container *containers.Container) api.Container {
return api.Container{
ID: container.ID,
Labels: container.Labels,
Image: container.Image,
Runtime: container.Runtime,
ID: container.ID,
Labels: container.Labels,
Image: container.Image,
Runtime: &api.Container_Runtime{
Name: container.Runtime.Name,
Options: container.Runtime.Options,
},
Spec: &types.Any{
TypeUrl: specs.Version,
Value: container.Spec,
@ -36,12 +39,15 @@ func containerToProto(container *containers.Container) api.Container {
func containerFromProto(containerpb *api.Container) containers.Container {
return containers.Container{
ID: containerpb.ID,
Labels: containerpb.Labels,
Image: containerpb.Image,
Runtime: containerpb.Runtime,
Spec: containerpb.Spec.Value,
RootFS: containerpb.RootFS,
ID: containerpb.ID,
Labels: containerpb.Labels,
Image: containerpb.Image,
Runtime: containers.RuntimeInfo{
Name: containerpb.Runtime.Name,
Options: containerpb.Runtime.Options,
},
Spec: containerpb.Spec.Value,
RootFS: containerpb.RootFS,
}
}

5
services/containers/service.go
View File

@ -96,7 +96,10 @@ func (s *Service) Create(ctx context.Context, req *api.CreateContainerRequest) (
if err := s.emit(ctx, "/containers/create", event.ContainerCreate{
ContainerID: resp.Container.ID,
Image: resp.Container.Image,
Runtime: resp.Container.Runtime,
Runtime: &event.ContainerCreate_Runtime{
Name: resp.Container.Runtime.Name,
Options: resp.Container.Runtime.Options,
},
}); err != nil {
return &resp, err
}

6
services/content/reader.go
View File

@ -26,7 +26,7 @@ func (rr *remoteReader) Read(p []byte) (n int, err error) {
p = p[n:]
for len(p) > 0 {
var resp *contentapi.ReadResponse
var resp *contentapi.ReadContentResponse
// fill our buffer up until we can fill p.
resp, err = rr.client.Recv()
if err != nil {
@ -56,7 +56,7 @@ type remoteReaderAt struct {
}
func (ra *remoteReaderAt) ReadAt(p []byte, off int64) (n int, err error) {
rr := &contentapi.ReadRequest{
rr := &contentapi.ReadContentRequest{
Digest: ra.digest,
Offset: off,
Size_: int64(len(p)),
@ -67,7 +67,7 @@ func (ra *remoteReaderAt) ReadAt(p []byte, off int64) (n int, err error) {
}
for len(p) > 0 {
var resp *contentapi.ReadResponse
var resp *contentapi.ReadContentResponse
// fill our buffer up until we can fill p.
resp, err = rc.Recv()
if err != nil {

16
services/content/service.go
View File

@ -137,7 +137,7 @@ func (s *Service) Delete(ctx context.Context, req *api.DeleteContentRequest) (*e
return &empty.Empty{}, nil
}
func (s *Service) Read(req *api.ReadRequest, session api.Content_ReadServer) error {
func (s *Service) Read(req *api.ReadContentRequest, session api.Content_ReadServer) error {
if err := req.Digest.Validate(); err != nil {
return grpc.Errorf(codes.InvalidArgument, "%v: %v", req.Digest, err)
}
@ -193,7 +193,7 @@ func (s *Service) Read(req *api.ReadRequest, session api.Content_ReadServer) err
return nil
}
// readResponseWriter is a writer that places the output into ReadResponse messages.
// readResponseWriter is a writer that places the output into ReadContentRequest messages.
//
// This allows io.CopyBuffer to do the heavy lifting of chunking the responses
// into the buffer size.
@ -203,7 +203,7 @@ type readResponseWriter struct {
}
func (rw *readResponseWriter) Write(p []byte) (n int, err error) {
if err := rw.session.Send(&api.ReadResponse{
if err := rw.session.Send(&api.ReadContentResponse{
Offset: rw.offset,
Data: p,
}); err != nil {
@ -215,9 +215,9 @@ func (rw *readResponseWriter) Write(p []byte) (n int, err error) {
}
func (s *Service) Status(ctx context.Context, req *api.StatusRequest) (*api.StatusResponse, error) {
statuses, err := s.store.Status(ctx, req.Regexp)
statuses, err := s.store.Status(ctx, req.Filter)
if err != nil {
return nil, serverErrorToGRPC(err, req.Regexp)
return nil, serverErrorToGRPC(err, req.Filter)
}
var resp api.StatusResponse
@ -238,14 +238,14 @@ func (s *Service) Status(ctx context.Context, req *api.StatusRequest) (*api.Stat
func (s *Service) Write(session api.Content_WriteServer) (err error) {
var (
ctx = session.Context()
msg api.WriteResponse
req *api.WriteRequest
msg api.WriteContentResponse
req *api.WriteContentRequest
ref string
total int64
expected digest.Digest
)
defer func(msg *api.WriteResponse) {
defer func(msg *api.WriteContentResponse) {
// pump through the last message if no error was encountered
if err != nil {
if grpc.Code(err) != codes.AlreadyExists {

8
services/content/store.go
View File

@ -75,7 +75,7 @@ func (rs *remoteStore) Delete(ctx context.Context, dgst digest.Digest) error {
}
func (rs *remoteStore) Reader(ctx context.Context, dgst digest.Digest) (io.ReadCloser, error) {
client, err := rs.client.Read(ctx, &contentapi.ReadRequest{Digest: dgst})
client, err := rs.client.Read(ctx, &contentapi.ReadContentRequest{Digest: dgst})
if err != nil {
return nil, err
}
@ -93,9 +93,9 @@ func (rs *remoteStore) ReaderAt(ctx context.Context, dgst digest.Digest) (io.Rea
}, nil
}
func (rs *remoteStore) Status(ctx context.Context, re string) ([]content.Status, error) {
func (rs *remoteStore) Status(ctx context.Context, filter string) ([]content.Status, error) {
resp, err := rs.client.Status(ctx, &contentapi.StatusRequest{
Regexp: re,
Filter: filter,
})
if err != nil {
return nil, rewriteGRPCError(err)
@ -146,7 +146,7 @@ func (rs *remoteStore) negotiate(ctx context.Context, ref string, size int64, ex
return nil, 0, err
}
if err := wrclient.Send(&contentapi.WriteRequest{
if err := wrclient.Send(&contentapi.WriteContentRequest{
Action: contentapi.WriteActionStat,
Ref: ref,
Total: size,

8
services/content/writer.go
View File

@ -17,7 +17,7 @@ type remoteWriter struct {
}
// send performs a synchronous req-resp cycle on the client.
func (rw *remoteWriter) send(req *contentapi.WriteRequest) (*contentapi.WriteResponse, error) {
func (rw *remoteWriter) send(req *contentapi.WriteContentRequest) (*contentapi.WriteContentResponse, error) {
if err := rw.client.Send(req); err != nil {
return nil, err
}
@ -35,7 +35,7 @@ func (rw *remoteWriter) send(req *contentapi.WriteRequest) (*contentapi.WriteRes
}
func (rw *remoteWriter) Status() (content.Status, error) {
resp, err := rw.send(&contentapi.WriteRequest{
resp, err := rw.send(&contentapi.WriteContentRequest{
Action: contentapi.WriteActionStat,
})
if err != nil {
@ -57,7 +57,7 @@ func (rw *remoteWriter) Digest() digest.Digest {
func (rw *remoteWriter) Write(p []byte) (n int, err error) {
offset := rw.offset
resp, err := rw.send(&contentapi.WriteRequest{
resp, err := rw.send(&contentapi.WriteContentRequest{
Action: contentapi.WriteActionWrite,
Offset: offset,
Data: p,
@ -79,7 +79,7 @@ func (rw *remoteWriter) Write(p []byte) (n int, err error) {
}
func (rw *remoteWriter) Commit(size int64, expected digest.Digest) error {
resp, err := rw.send(&contentapi.WriteRequest{
resp, err := rw.send(&contentapi.WriteContentRequest{
Action: contentapi.WriteActionCommit,
Total: size,
Offset: rw.offset,

2
services/events/service.go
View File

@ -35,7 +35,7 @@ func (s *Service) Register(server *grpc.Server) error {
return nil
}
func (s *Service) EventStream(req *api.EventStreamRequest, srv api.Events_EventStreamServer) error {
func (s *Service) Stream(req *api.StreamEventsRequest, srv api.Events_StreamServer) error {
clientID := fmt.Sprintf("%d", time.Now().UnixNano())
for {
e := <-s.emitter.Events(srv.Context(), clientID)

89
services/execution/collector.go
View File

@ -1,89 +0,0 @@
package execution
import (
"sync"
"github.com/containerd/containerd/plugin"
"golang.org/x/net/context"
)
func newCollector(ctx context.Context, runtimes map[string]plugin.Runtime) (*collector, error) {
c := &collector{
context: ctx,
ch: make(chan *plugin.Event, 2048),
eventClients: make(map[*eventClient]struct{}),
}
for _, r := range runtimes {
if err := c.collect(r); err != nil {
return nil, err
}
}
// run the publisher
go c.publisher()
// run a goroutine that waits for the context to be done
// and closes the channel after all writes have finished
go c.waitDone()
return c, nil
}
type eventClient struct {
eCh chan error
w *grpcEventWriter
}
type collector struct {
mu sync.Mutex
wg sync.WaitGroup
context context.Context
ch chan *plugin.Event
eventClients map[*eventClient]struct{}
}
// collect collects events from the provided runtime
func (c *collector) collect(r plugin.Runtime) error {
c.wg.Add(1)
go func() {
defer c.wg.Done()
for e := range r.Events(c.context) {
c.ch <- e
}
}()
return nil
}
func (c *collector) forward(w *grpcEventWriter) error {
client := &eventClient{
w: w,
eCh: make(chan error, 1),
}
c.mu.Lock()
c.eventClients[client] = struct{}{}
c.mu.Unlock()
err := <-client.eCh
c.mu.Lock()
delete(c.eventClients, client)
c.mu.Unlock()
return err
}
func (c *collector) publisher() {
for e := range c.ch {
c.mu.Lock()
for client := range c.eventClients {
if err := client.w.Write(e); err != nil {
client.eCh <- err
}
}
c.mu.Unlock()
}
}
// waitDone waits for the context to finish, waits for all the goroutines to finish
// collecting grpc events from the shim, and closes the output channel
func (c *collector) waitDone() {
<-c.context.Done()
c.wg.Wait()
close(c.ch)
}

123
services/execution/service.go
View File

@ -67,26 +67,20 @@ func New(ic *plugin.InitContext) (interface{}, error) {
r := rr.(plugin.Runtime)
runtimes[r.ID()] = r
}
c, err := newCollector(ic.Context, runtimes)
if err != nil {
return nil, err
}
e := events.GetPoster(ic.Context)
return &Service{
runtimes: runtimes,
db: m.(*bolt.DB),
collector: c,
store: ct.(content.Store),
emitter: e,
runtimes: runtimes,
db: m.(*bolt.DB),
store: ct.(content.Store),
emitter: e,
}, nil
}
type Service struct {
runtimes map[string]plugin.Runtime
db *bolt.DB
collector *collector
store content.Store
emitter events.Poster
runtimes map[string]plugin.Runtime
db *bolt.DB
store content.Store
emitter events.Poster
}
func (s *Service) Register(server *grpc.Server) error {
@ -94,7 +88,7 @@ func (s *Service) Register(server *grpc.Server) error {
return nil
}
func (s *Service) Create(ctx context.Context, r *api.CreateRequest) (*api.CreateResponse, error) {
func (s *Service) Create(ctx context.Context, r *api.CreateTaskRequest) (*api.CreateTaskResponse, error) {
var (
checkpointPath string
err error
@ -152,7 +146,7 @@ func (s *Service) Create(ctx context.Context, r *api.CreateRequest) (*api.Create
Options: m.Options,
})
}
runtime, err := s.getRuntime(container.Runtime)
runtime, err := s.getRuntime(container.Runtime.Name)
if err != nil {
return nil, err
}
@ -171,13 +165,13 @@ func (s *Service) Create(ctx context.Context, r *api.CreateRequest) (*api.Create
return nil, err
}
return &api.CreateResponse{
return &api.CreateTaskResponse{
ContainerID: r.ContainerID,
Pid: state.Pid,
}, nil
}
func (s *Service) Start(ctx context.Context, r *api.StartRequest) (*google_protobuf.Empty, error) {
func (s *Service) Start(ctx context.Context, r *api.StartTaskRequest) (*google_protobuf.Empty, error) {
t, err := s.getTask(ctx, r.ContainerID)
if err != nil {
return nil, err
@ -195,7 +189,7 @@ func (s *Service) Start(ctx context.Context, r *api.StartRequest) (*google_proto
return empty, nil
}
func (s *Service) Delete(ctx context.Context, r *api.DeleteRequest) (*api.DeleteResponse, error) {
func (s *Service) Delete(ctx context.Context, r *api.DeleteTaskRequest) (*api.DeleteResponse, error) {
t, err := s.getTask(ctx, r.ContainerID)
if err != nil {
return nil, err
@ -208,16 +202,17 @@ func (s *Service) Delete(ctx context.Context, r *api.DeleteRequest) (*api.Delete
if err != nil {
return nil, err
}
if err := s.emit(ctx, "/tasks/delete", event.TaskDelete{
ContainerID: r.ContainerID,
Pid: exit.Pid,
ExitStatus: exit.Status,
}); err != nil {
return nil, err
}
return &api.DeleteResponse{
ExitStatus: exit.Status,
ExitedAt: exit.Timestamp,
Pid: exit.Pid,
}, nil
}
@ -233,6 +228,7 @@ func (s *Service) DeleteProcess(ctx context.Context, r *api.DeleteProcessRequest
return &api.DeleteResponse{
ExitStatus: exit.Status,
ExitedAt: exit.Timestamp,
Pid: exit.Pid,
}, nil
}
@ -271,7 +267,7 @@ func taskFromContainerd(ctx context.Context, c plugin.Task) (*task.Task, error)
}, nil
}
func (s *Service) Info(ctx context.Context, r *api.InfoRequest) (*api.InfoResponse, error) {
func (s *Service) Get(ctx context.Context, r *api.GetTaskRequest) (*api.GetTaskResponse, error) {
task, err := s.getTask(ctx, r.ContainerID)
if err != nil {
return nil, err
@ -280,13 +276,13 @@ func (s *Service) Info(ctx context.Context, r *api.InfoRequest) (*api.InfoRespon
if err != nil {
return nil, err
}
return &api.InfoResponse{
return &api.GetTaskResponse{
Task: t,
}, nil
}
func (s *Service) List(ctx context.Context, r *api.ListRequest) (*api.ListResponse, error) {
resp := &api.ListResponse{}
func (s *Service) List(ctx context.Context, r *api.ListTasksRequest) (*api.ListTasksResponse, error) {
resp := &api.ListTasksResponse{}
for _, r := range s.runtimes {
tasks, err := r.Tasks(ctx)
if err != nil {
@ -303,7 +299,7 @@ func (s *Service) List(ctx context.Context, r *api.ListRequest) (*api.ListRespon
return resp, nil
}
func (s *Service) Pause(ctx context.Context, r *api.PauseRequest) (*google_protobuf.Empty, error) {
func (s *Service) Pause(ctx context.Context, r *api.PauseTaskRequest) (*google_protobuf.Empty, error) {
t, err := s.getTask(ctx, r.ContainerID)
if err != nil {
return nil, err
@ -315,7 +311,7 @@ func (s *Service) Pause(ctx context.Context, r *api.PauseRequest) (*google_proto
return empty, nil
}
func (s *Service) Resume(ctx context.Context, r *api.ResumeRequest) (*google_protobuf.Empty, error) {
func (s *Service) Resume(ctx context.Context, r *api.ResumeTaskRequest) (*google_protobuf.Empty, error) {
t, err := s.getTask(ctx, r.ContainerID)
if err != nil {
return nil, err
@ -348,7 +344,7 @@ func (s *Service) Kill(ctx context.Context, r *api.KillRequest) (*google_protobu
return empty, nil
}
func (s *Service) Processes(ctx context.Context, r *api.ProcessesRequest) (*api.ProcessesResponse, error) {
func (s *Service) ListProcesses(ctx context.Context, r *api.ListProcessesRequest) (*api.ListProcessesResponse, error) {
t, err := s.getTask(ctx, r.ContainerID)
if err != nil {
return nil, err
@ -365,22 +361,12 @@ func (s *Service) Processes(ctx context.Context, r *api.ProcessesRequest) (*api.
Pid: pid,
})
}
resp := &api.ProcessesResponse{
return &api.ListProcessesResponse{
Processes: ps,
}
return resp, nil
}, nil
}
func (s *Service) Events(r *api.EventsRequest, server api.Tasks_EventsServer) error {
w := &grpcEventWriter{
server: server,
}
return s.collector.forward(w)
}
func (s *Service) Exec(ctx context.Context, r *api.ExecRequest) (*api.ExecResponse, error) {
func (s *Service) Exec(ctx context.Context, r *api.ExecProcessRequest) (*api.ExecProcessResponse, error) {
t, err := s.getTask(ctx, r.ContainerID)
if err != nil {
return nil, err
@ -401,12 +387,12 @@ func (s *Service) Exec(ctx context.Context, r *api.ExecRequest) (*api.ExecRespon
if err != nil {
return nil, err
}
return &api.ExecResponse{
return &api.ExecProcessResponse{
Pid: state.Pid,
}, nil
}
func (s *Service) Pty(ctx context.Context, r *api.PtyRequest) (*google_protobuf.Empty, error) {
func (s *Service) ResizePty(ctx context.Context, r *api.ResizePtyRequest) (*google_protobuf.Empty, error) {
t, err := s.getTask(ctx, r.ContainerID)
if err != nil {
return nil, err
@ -420,18 +406,20 @@ func (s *Service) Pty(ctx context.Context, r *api.PtyRequest) (*google_protobuf.
return empty, nil
}
func (s *Service) CloseStdin(ctx context.Context, r *api.CloseStdinRequest) (*google_protobuf.Empty, error) {
func (s *Service) CloseIO(ctx context.Context, r *api.CloseIORequest) (*google_protobuf.Empty, error) {
t, err := s.getTask(ctx, r.ContainerID)
if err != nil {
return nil, err
}
if err := t.CloseStdin(ctx, r.Pid); err != nil {
return nil, err
if r.Stdin {
if err := t.CloseStdin(ctx, r.Pid); err != nil {
return nil, err
}
}
return empty, nil
}
func (s *Service) Checkpoint(ctx context.Context, r *api.CheckpointRequest) (*api.CheckpointResponse, error) {
func (s *Service) Checkpoint(ctx context.Context, r *api.CheckpointTaskRequest) (*api.CheckpointTaskResponse, error) {
t, err := s.getTask(ctx, r.ContainerID)
if err != nil {
return nil, err
@ -441,16 +429,7 @@ func (s *Service) Checkpoint(ctx context.Context, r *api.CheckpointRequest) (*ap
return nil, err
}
defer os.RemoveAll(image)
if err := t.Checkpoint(ctx, plugin.CheckpointOpts{
Exit: r.Exit,
AllowTCP: r.AllowTcp,
AllowTerminal: r.AllowTerminal,
AllowUnixSockets: r.AllowUnixSockets,
FileLocks: r.FileLocks,
// ParentImage: r.ParentImage,
EmptyNamespaces: r.EmptyNamespaces,
Path: image,
}); err != nil {
if err := t.Checkpoint(ctx, image, r.Options); err != nil {
return nil, err
}
// write checkpoint to the content store
@ -469,7 +448,7 @@ func (s *Service) Checkpoint(ctx context.Context, r *api.CheckpointRequest) (*ap
if err != nil {
return nil, err
}
return &api.CheckpointResponse{
return &api.CheckpointTaskResponse{
Descriptors: []*descriptor.Descriptor{
cp,
specD,
@ -523,31 +502,3 @@ func (s *Service) emit(ctx context.Context, topic string, evt interface{}) error
return nil
}
type grpcEventWriter struct {
server api.Tasks_EventsServer
}
func (g *grpcEventWriter) Write(e *plugin.Event) error {
var t task.Event_EventType
switch e.Type {
case plugin.ExitEvent:
t = task.Event_EXIT
case plugin.ExecAddEvent:
t = task.Event_EXEC_ADDED
case plugin.PausedEvent:
t = task.Event_PAUSED
case plugin.CreateEvent:
t = task.Event_CREATE
case plugin.StartEvent:
t = task.Event_START
case plugin.OOMEvent:
t = task.Event_OOM
}
return g.server.Send(&task.Event{
Type: t,
ID: e.ID,
Pid: e.Pid,
ExitStatus: e.ExitStatus,
})
}

10
services/images/client.go
View File

@ -18,10 +18,10 @@ func NewStoreFromClient(client imagesapi.ImagesClient) images.Store {
}
}
func (s *remoteStore) Put(ctx context.Context, name string, desc ocispec.Descriptor) error {
func (s *remoteStore) Update(ctx context.Context, name string, desc ocispec.Descriptor) error {
// TODO(stevvooe): Consider that the remote may want to augment and return
// a modified image.
_, err := s.client.Put(ctx, &imagesapi.PutRequest{
_, err := s.client.Update(ctx, &imagesapi.UpdateImageRequest{
Image: imagesapi.Image{
Name: name,
Target: descToProto(&desc),
@ -32,7 +32,7 @@ func (s *remoteStore) Put(ctx context.Context, name string, desc ocispec.Descrip
}
func (s *remoteStore) Get(ctx context.Context, name string) (images.Image, error) {
resp, err := s.client.Get(ctx, &imagesapi.GetRequest{
resp, err := s.client.Get(ctx, &imagesapi.GetImageRequest{
Name: name,
})
if err != nil {
@ -43,7 +43,7 @@ func (s *remoteStore) Get(ctx context.Context, name string) (images.Image, error
}
func (s *remoteStore) List(ctx context.Context) ([]images.Image, error) {
resp, err := s.client.List(ctx, &imagesapi.ListRequest{})
resp, err := s.client.List(ctx, &imagesapi.ListImagesRequest{})
if err != nil {
return nil, rewriteGRPCError(err)
}
@ -52,7 +52,7 @@ func (s *remoteStore) List(ctx context.Context) ([]images.Image, error) {
}
func (s *remoteStore) Delete(ctx context.Context, name string) error {
_, err := s.client.Delete(ctx, &imagesapi.DeleteRequest{
_, err := s.client.Delete(ctx, &imagesapi.DeleteImageRequest{
Name: name,
})

29
services/images/service.go
View File

@ -48,8 +48,8 @@ func (s *Service) Register(server *grpc.Server) error {
return nil
}
func (s *Service) Get(ctx context.Context, req *imagesapi.GetRequest) (*imagesapi.GetResponse, error) {
var resp imagesapi.GetResponse
func (s *Service) Get(ctx context.Context, req *imagesapi.GetImageRequest) (*imagesapi.GetImageResponse, error) {
var resp imagesapi.GetImageResponse
return &resp, s.withStoreView(ctx, func(ctx context.Context, store images.Store) error {
image, err := store.Get(ctx, req.Name)
@ -62,25 +62,28 @@ func (s *Service) Get(ctx context.Context, req *imagesapi.GetRequest) (*imagesap
})
}
func (s *Service) Put(ctx context.Context, req *imagesapi.PutRequest) (*empty.Empty, error) {
func (s *Service) Update(ctx context.Context, req *imagesapi.UpdateImageRequest) (*imagesapi.UpdateImageResponse, error) {
if err := s.withStoreUpdate(ctx, func(ctx context.Context, store images.Store) error {
return mapGRPCError(store.Put(ctx, req.Image.Name, descFromProto(&req.Image.Target)), req.Image.Name)
return mapGRPCError(store.Update(ctx, req.Image.Name, descFromProto(&req.Image.Target)), req.Image.Name)
}); err != nil {
return &empty.Empty{}, err
return nil, err
}
if err := s.emit(ctx, "/images/put", event.ImagePut{
if err := s.emit(ctx, "/images/update", event.ImageUpdate{
Name: req.Image.Name,
Labels: req.Image.Labels,
}); err != nil {
return &empty.Empty{}, err
return nil, err
}
return &empty.Empty{}, nil
// TODO: get image back out to return
return &imagesapi.UpdateImageResponse{
//Image: nil,
}, nil
}
func (s *Service) List(ctx context.Context, _ *imagesapi.ListRequest) (*imagesapi.ListResponse, error) {
var resp imagesapi.ListResponse
func (s *Service) List(ctx context.Context, _ *imagesapi.ListImagesRequest) (*imagesapi.ListImagesResponse, error) {
var resp imagesapi.ListImagesResponse
return &resp, s.withStoreView(ctx, func(ctx context.Context, store images.Store) error {
images, err := store.List(ctx)
@ -93,17 +96,17 @@ func (s *Service) List(ctx context.Context, _ *imagesapi.ListRequest) (*imagesap
})
}
func (s *Service) Delete(ctx context.Context, req *imagesapi.DeleteRequest) (*empty.Empty, error) {
func (s *Service) Delete(ctx context.Context, req *imagesapi.DeleteImageRequest) (*empty.Empty, error) {
if err := s.withStoreUpdate(ctx, func(ctx context.Context, store images.Store) error {
return mapGRPCError(store.Delete(ctx, req.Name), req.Name)
}); err != nil {
return &empty.Empty{}, err
return nil, err
}
if err := s.emit(ctx, "/images/delete", event.ImageDelete{
Name: req.Name,
}); err != nil {
return &empty.Empty{}, err
return nil, err
}
return &empty.Empty{}, nil

29
services/snapshot/client.go
View File

@ -9,6 +9,7 @@ import (
"google.golang.org/grpc/codes"
snapshotapi "github.com/containerd/containerd/api/services/snapshot"
mountapi "github.com/containerd/containerd/api/types/mount"
"github.com/containerd/containerd/mount"
"github.com/containerd/containerd/snapshot"
"github.com/pkg/errors"
@ -16,18 +17,18 @@ import (
// NewSnapshotterFromClient returns a new Snapshotter which communicates
// over a GRPC connection.
func NewSnapshotterFromClient(client snapshotapi.SnapshotClient) snapshot.Snapshotter {
func NewSnapshotterFromClient(client snapshotapi.SnapshotsClient) snapshot.Snapshotter {
return &remoteSnapshotter{
client: client,
}
}
type remoteSnapshotter struct {
client snapshotapi.SnapshotClient
client snapshotapi.SnapshotsClient
}
func (r *remoteSnapshotter) Stat(ctx context.Context, key string) (snapshot.Info, error) {
resp, err := r.client.Stat(ctx, &snapshotapi.StatRequest{Key: key})
resp, err := r.client.Stat(ctx, &snapshotapi.StatSnapshotRequest{Key: key})
if err != nil {
return snapshot.Info{}, rewriteGRPCError(err)
}
@ -47,27 +48,27 @@ func (r *remoteSnapshotter) Mounts(ctx context.Context, key string) ([]mount.Mou
if err != nil {
return nil, rewriteGRPCError(err)
}
return toMounts(resp), nil
return toMounts(resp.Mounts), nil
}
func (r *remoteSnapshotter) Prepare(ctx context.Context, key, parent string) ([]mount.Mount, error) {
resp, err := r.client.Prepare(ctx, &snapshotapi.PrepareRequest{Key: key, Parent: parent})
resp, err := r.client.Prepare(ctx, &snapshotapi.PrepareSnapshotRequest{Key: key, Parent: parent})
if err != nil {
return nil, rewriteGRPCError(err)
}
return toMounts(resp), nil
return toMounts(resp.Mounts), nil
}
func (r *remoteSnapshotter) View(ctx context.Context, key, parent string) ([]mount.Mount, error) {
resp, err := r.client.View(ctx, &snapshotapi.PrepareRequest{Key: key, Parent: parent})
resp, err := r.client.View(ctx, &snapshotapi.ViewSnapshotRequest{Key: key, Parent: parent})
if err != nil {
return nil, rewriteGRPCError(err)
}
return toMounts(resp), nil
return toMounts(resp.Mounts), nil
}
func (r *remoteSnapshotter) Commit(ctx context.Context, name, key string) error {
_, err := r.client.Commit(ctx, &snapshotapi.CommitRequest{
_, err := r.client.Commit(ctx, &snapshotapi.CommitSnapshotRequest{
Name: name,
Key: key,
})
@ -75,12 +76,12 @@ func (r *remoteSnapshotter) Commit(ctx context.Context, name, key string) error
}
func (r *remoteSnapshotter) Remove(ctx context.Context, key string) error {
_, err := r.client.Remove(ctx, &snapshotapi.RemoveRequest{Key: key})
_, err := r.client.Remove(ctx, &snapshotapi.RemoveSnapshotRequest{Key: key})
return rewriteGRPCError(err)
}
func (r *remoteSnapshotter) Walk(ctx context.Context, fn func(context.Context, snapshot.Info) error) error {
sc, err := r.client.List(ctx, &snapshotapi.ListRequest{})
sc, err := r.client.List(ctx, &snapshotapi.ListSnapshotsRequest{})
if err != nil {
rewriteGRPCError(err)
}
@ -145,9 +146,9 @@ func toUsage(resp *snapshotapi.UsageResponse) snapshot.Usage {
}
}
func toMounts(resp *snapshotapi.MountsResponse) []mount.Mount {
mounts := make([]mount.Mount, len(resp.Mounts))
for i, m := range resp.Mounts {
func toMounts(mm []*mountapi.Mount) []mount.Mount {
mounts := make([]mount.Mount, len(mm))
for i, m := range mm {
mounts[i] = mount.Mount{
Type: m.Type,
Source: m.Source,

42
services/snapshot/service.go
View File

@ -50,11 +50,11 @@ func newService(snapshotter snapshot.Snapshotter, evts events.Poster) (*service,
}
func (s *service) Register(gs *grpc.Server) error {
snapshotapi.RegisterSnapshotServer(gs, s)
snapshotapi.RegisterSnapshotsServer(gs, s)
return nil
}
func (s *service) Prepare(ctx context.Context, pr *snapshotapi.PrepareRequest) (*snapshotapi.MountsResponse, error) {
func (s *service) Prepare(ctx context.Context, pr *snapshotapi.PrepareSnapshotRequest) (*snapshotapi.PrepareSnapshotResponse, error) {
log.G(ctx).WithField("parent", pr.Parent).WithField("key", pr.Key).Debugf("Preparing snapshot")
// TODO: Apply namespace
// TODO: Lookup snapshot id from metadata store
@ -69,11 +69,12 @@ func (s *service) Prepare(ctx context.Context, pr *snapshotapi.PrepareRequest) (
}); err != nil {
return nil, err
}
return fromMounts(mounts), nil
return &snapshotapi.PrepareSnapshotResponse{
Mounts: fromMounts(mounts),
}, nil
}
func (s *service) View(ctx context.Context, pr *snapshotapi.PrepareRequest) (*snapshotapi.MountsResponse, error) {
func (s *service) View(ctx context.Context, pr *snapshotapi.ViewSnapshotRequest) (*snapshotapi.ViewSnapshotResponse, error) {
log.G(ctx).WithField("parent", pr.Parent).WithField("key", pr.Key).Debugf("Preparing view snapshot")
// TODO: Apply namespace
// TODO: Lookup snapshot id from metadata store
@ -81,7 +82,9 @@ func (s *service) View(ctx context.Context, pr *snapshotapi.PrepareRequest) (*sn
if err != nil {
return nil, grpcError(err)
}
return fromMounts(mounts), nil
return &snapshotapi.ViewSnapshotResponse{
Mounts: fromMounts(mounts),
}, nil
}
func (s *service) Mounts(ctx context.Context, mr *snapshotapi.MountsRequest) (*snapshotapi.MountsResponse, error) {
@ -92,10 +95,12 @@ func (s *service) Mounts(ctx context.Context, mr *snapshotapi.MountsRequest) (*s
if err != nil {
return nil, grpcError(err)
}
return fromMounts(mounts), nil
return &snapshotapi.MountsResponse{
Mounts: fromMounts(mounts),
}, nil
}
func (s *service) Commit(ctx context.Context, cr *snapshotapi.CommitRequest) (*protoempty.Empty, error) {
func (s *service) Commit(ctx context.Context, cr *snapshotapi.CommitSnapshotRequest) (*protoempty.Empty, error) {
log.G(ctx).WithField("key", cr.Key).WithField("name", cr.Name).Debugf("Committing snapshot")
// TODO: Apply namespace
// TODO: Lookup snapshot id from metadata store
@ -112,7 +117,7 @@ func (s *service) Commit(ctx context.Context, cr *snapshotapi.CommitRequest) (*p
return empty, nil
}
func (s *service) Remove(ctx context.Context, rr *snapshotapi.RemoveRequest) (*protoempty.Empty, error) {
func (s *service) Remove(ctx context.Context, rr *snapshotapi.RemoveSnapshotRequest) (*protoempty.Empty, error) {
log.G(ctx).WithField("key", rr.Key).Debugf("Removing snapshot")
// TODO: Apply namespace
// TODO: Lookup snapshot id from metadata store
@ -128,7 +133,7 @@ func (s *service) Remove(ctx context.Context, rr *snapshotapi.RemoveRequest) (*p
return empty, nil
}
func (s *service) Stat(ctx context.Context, sr *snapshotapi.StatRequest) (*snapshotapi.StatResponse, error) {
func (s *service) Stat(ctx context.Context, sr *snapshotapi.StatSnapshotRequest) (*snapshotapi.StatSnapshotResponse, error) {
log.G(ctx).WithField("key", sr.Key).Debugf("Statting snapshot")
// TODO: Apply namespace
info, err := s.snapshotter.Stat(ctx, sr.Key)
@ -136,16 +141,15 @@ func (s *service) Stat(ctx context.Context, sr *snapshotapi.StatRequest) (*snaps
return nil, grpcError(err)
}
return &snapshotapi.StatResponse{Info: fromInfo(info)}, nil
return &snapshotapi.StatSnapshotResponse{Info: fromInfo(info)}, nil
}
func (s *service) List(sr *snapshotapi.ListRequest, ss snapshotapi.Snapshot_ListServer) error {
func (s *service) List(sr *snapshotapi.ListSnapshotsRequest, ss snapshotapi.Snapshots_ListServer) error {
// TODO: Apply namespace
var (
buffer []snapshotapi.Info
sendBlock = func(block []snapshotapi.Info) error {
return ss.Send(&snapshotapi.ListResponse{
return ss.Send(&snapshotapi.ListSnapshotsResponse{
Info: block,
})
}
@ -223,18 +227,16 @@ func fromUsage(usage snapshot.Usage) *snapshotapi.UsageResponse {
}
}
func fromMounts(mounts []mount.Mount) *snapshotapi.MountsResponse {
resp := &snapshotapi.MountsResponse{
Mounts: make([]*mounttypes.Mount, len(mounts)),
}
func fromMounts(mounts []mount.Mount) []*mounttypes.Mount {
out := make([]*mounttypes.Mount, len(mounts))
for i, m := range mounts {
resp.Mounts[i] = &mounttypes.Mount{
out[i] = &mounttypes.Mount{
Type: m.Type,
Source: m.Source,
Options: m.Options,
}
}
return resp
return out
}
func (s *service) emit(ctx context.Context, topic string, evt interface{}) error {

86
task.go
View File

@ -11,10 +11,13 @@ import (
"syscall"
"github.com/containerd/containerd/api/services/containers"
eventsapi "github.com/containerd/containerd/api/services/events"
"github.com/containerd/containerd/api/services/execution"
taskapi "github.com/containerd/containerd/api/types/task"
"github.com/containerd/containerd/api/types/event"
tasktypes "github.com/containerd/containerd/api/types/task"
"github.com/containerd/containerd/content"
"github.com/containerd/containerd/rootfs"
"github.com/gogo/protobuf/proto"
"github.com/opencontainers/image-spec/specs-go/v1"
specs "github.com/opencontainers/runtime-spec/specs-go"
)
@ -31,7 +34,13 @@ const (
Pausing TaskStatus = "pausing"
)
type CheckpointOpts func(*execution.CheckpointRequest) error
type IOCloserOpts func(*execution.CloseIORequest)
func WithStdinCloser(r *execution.CloseIORequest) {
r.Stdin = true
}
type CheckpointOpts func(*execution.CheckpointTaskRequest) error
type Task interface {
Pid() uint32
@ -44,7 +53,7 @@ type Task interface {
Wait(context.Context) (uint32, error)
Exec(context.Context, *specs.Process, IOCreation) (Process, error)
Processes(context.Context) ([]uint32, error)
CloseStdin(context.Context) error
CloseIO(context.Context, ...IOCloserOpts) error
Resize(ctx context.Context, w, h uint32) error
IO() *IO
Checkpoint(context.Context, ...CheckpointOpts) (v1.Descriptor, error)
@ -56,7 +65,7 @@ type Process interface {
Delete(context.Context) (uint32, error)
Kill(context.Context, syscall.Signal) error
Wait(context.Context) (uint32, error)
CloseStdin(context.Context) error
CloseIO(context.Context, ...IOCloserOpts) error
Resize(ctx context.Context, w, h uint32) error
IO() *IO
}
@ -70,7 +79,7 @@ type task struct {
containerID string
pid uint32
deferred *execution.CreateRequest
deferred *execution.CreateTaskRequest
pidSync chan struct{}
}
@ -90,7 +99,7 @@ func (t *task) Start(ctx context.Context) error {
close(t.pidSync)
return nil
}
_, err := t.client.TaskService().Start(ctx, &execution.StartRequest{
_, err := t.client.TaskService().Start(ctx, &execution.StartTaskRequest{
ContainerID: t.containerID,
})
return err
@ -108,21 +117,21 @@ func (t *task) Kill(ctx context.Context, s syscall.Signal) error {
}
func (t *task) Pause(ctx context.Context) error {
_, err := t.client.TaskService().Pause(ctx, &execution.PauseRequest{
_, err := t.client.TaskService().Pause(ctx, &execution.PauseTaskRequest{
ContainerID: t.containerID,
})
return err
}
func (t *task) Resume(ctx context.Context) error {
_, err := t.client.TaskService().Resume(ctx, &execution.ResumeRequest{
_, err := t.client.TaskService().Resume(ctx, &execution.ResumeTaskRequest{
ContainerID: t.containerID,
})
return err
}
func (t *task) Status(ctx context.Context) (TaskStatus, error) {
r, err := t.client.TaskService().Info(ctx, &execution.InfoRequest{
r, err := t.client.TaskService().Get(ctx, &execution.GetTaskRequest{
ContainerID: t.containerID,
})
if err != nil {
@ -133,21 +142,30 @@ func (t *task) Status(ctx context.Context) (TaskStatus, error) {
// Wait is a blocking call that will wait for the task to exit and return the exit status
func (t *task) Wait(ctx context.Context) (uint32, error) {
events, err := t.client.TaskService().Events(ctx, &execution.EventsRequest{})
// TODO (ehazlett): add filtering for specific event
events, err := t.client.EventService().Stream(ctx, &eventsapi.StreamEventsRequest{})
if err != nil {
return UnknownExitStatus, err
}
<-t.pidSync
for {
e, err := events.Recv()
evt, err := events.Recv()
if err != nil {
return UnknownExitStatus, err
}
if e.Type != taskapi.Event_EXIT {
continue
}
if e.ID == t.containerID && e.Pid == t.pid {
return e.ExitStatus, nil
if evt.Event.TypeUrl == "types.containerd.io/containerd.v1.types.event.RuntimeEvent" {
e := &event.RuntimeEvent{}
if err := proto.Unmarshal(evt.Event.Value, e); err != nil {
return UnknownExitStatus, err
}
if e.Type != tasktypes.Event_EXIT {
continue
}
if e.ID == t.containerID && e.Pid == t.pid {
return e.ExitStatus, nil
}
}
}
}
@ -160,7 +178,7 @@ func (t *task) Delete(ctx context.Context) (uint32, error) {
if t.io != nil {
cerr = t.io.Close()
}
r, err := t.client.TaskService().Delete(ctx, &execution.DeleteRequest{
r, err := t.client.TaskService().Delete(ctx, &execution.DeleteTaskRequest{
ContainerID: t.containerID,
})
if err != nil {
@ -183,7 +201,7 @@ func (t *task) Exec(ctx context.Context, spec *specs.Process, ioCreate IOCreatio
}
func (t *task) Processes(ctx context.Context) ([]uint32, error) {
response, err := t.client.TaskService().Processes(ctx, &execution.ProcessesRequest{
response, err := t.client.TaskService().ListProcesses(ctx, &execution.ListProcessesRequest{
ContainerID: t.containerID,
})
if err != nil {
@ -196,11 +214,15 @@ func (t *task) Processes(ctx context.Context) ([]uint32, error) {
return out, nil
}
func (t *task) CloseStdin(ctx context.Context) error {
_, err := t.client.TaskService().CloseStdin(ctx, &execution.CloseStdinRequest{
func (t *task) CloseIO(ctx context.Context, opts ...IOCloserOpts) error {
r := &execution.CloseIORequest{
ContainerID: t.containerID,
Pid: t.pid,
})
}
for _, o := range opts {
o(r)
}
_, err := t.client.TaskService().CloseIO(ctx, r)
return err
}
@ -209,7 +231,7 @@ func (t *task) IO() *IO {
}
func (t *task) Resize(ctx context.Context, w, h uint32) error {
_, err := t.client.TaskService().Pty(ctx, &execution.PtyRequest{
_, err := t.client.TaskService().ResizePty(ctx, &execution.ResizePtyRequest{
ContainerID: t.containerID,
Width: w,
Height: h,
@ -218,28 +240,26 @@ func (t *task) Resize(ctx context.Context, w, h uint32) error {
return err
}
func WithExit(r *execution.CheckpointRequest) error {
r.Exit = true
func WithExit(r *execution.CheckpointTaskRequest) error {
r.Options["exit"] = "true"
return nil
}
func (t *task) Checkpoint(ctx context.Context, opts ...CheckpointOpts) (d v1.Descriptor, err error) {
request := &execution.CheckpointRequest{
request := &execution.CheckpointTaskRequest{
ContainerID: t.containerID,
Options: make(map[string]string),
}
for _, o := range opts {
if err := o(request); err != nil {
return d, err
}
}
// if we are not exiting the container after the checkpoint, make sure we pause it and resume after
// all other filesystem operations are completed
if !request.Exit {
if err := t.Pause(ctx); err != nil {
return d, err
}
defer t.Resume(ctx)
// make sure we pause it and resume after all other filesystem operations are completed
if err := t.Pause(ctx); err != nil {
return d, err
}
defer t.Resume(ctx)
cr, err := t.client.ContainerService().Get(ctx, &containers.GetContainerRequest{
ID: t.containerID,
})
@ -261,7 +281,7 @@ func (t *task) Checkpoint(ctx context.Context, opts ...CheckpointOpts) (d v1.Des
return t.writeIndex(ctx, &index)
}
func (t *task) checkpointTask(ctx context.Context, index *v1.Index, request *execution.CheckpointRequest) error {
func (t *task) checkpointTask(ctx context.Context, index *v1.Index, request *execution.CheckpointTaskRequest) error {
response, err := t.client.TaskService().Checkpoint(ctx, request)
if err != nil {
return err

2
windows/container.go
View File

@ -190,7 +190,7 @@ func (c *container) Processes(ctx context.Context) ([]uint32, error) {
return pids, nil
}
func (c *container) Checkpoint(ctx context.Context, opts plugin.CheckpointOpts) error {
func (c *container) Checkpoint(ctx context.Context, _ string, _ map[string]string) error {
return fmt.Errorf("Windows containers do not support checkpoint")
}

4
windows/runtime.go
View File

@ -169,10 +169,6 @@ func (r *Runtime) Get(ctx context.Context, id string) (plugin.Task, error) {
return c, nil
}
func (r *Runtime) Events(ctx context.Context) <-chan *plugin.Event {
return r.events
}
func (r *Runtime) sendEvent(id string, evType plugin.EventType, pid, exitStatus uint32, exitedAt time.Time) {
r.events <- &plugin.Event{
Timestamp: time.Now(),