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

Implement task update

Browse Source 
This allows tasks to have their resources updated as they are running.

Fixes #1067

Signed-off-by: Michael Crosby <crosbymichael@gmail.com>
This commit is contained in:
Michael Crosby 2017-06-26 16:38:49 -07:00
parent 1f478be14d
commit f36e0193a4
15 changed files with 749 additions and 152 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

369
api/services/tasks/v1/tasks.pb.go
View File

@ -30,6 +30,7 @@
ListProcessesResponse
CheckpointTaskRequest
CheckpointTaskResponse
UpdateTaskRequest
*/
package tasks
@ -388,6 +389,15 @@ func (m *CheckpointTaskResponse) Reset() { *m = CheckpointTas
func (*CheckpointTaskResponse) ProtoMessage() {}
func (*CheckpointTaskResponse) Descriptor() ([]byte, []int) { return fileDescriptorTasks, []int{20} }
type UpdateTaskRequest struct {
ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
Resources *google_protobuf1.Any `protobuf:"bytes,2,opt,name=resources" json:"resources,omitempty"`
}
func (m *UpdateTaskRequest) Reset() { *m = UpdateTaskRequest{} }
func (*UpdateTaskRequest) ProtoMessage() {}
func (*UpdateTaskRequest) Descriptor() ([]byte, []int) { return fileDescriptorTasks, []int{21} }
func init() {
proto.RegisterType((*CreateTaskRequest)(nil), "containerd.services.tasks.v1.CreateTaskRequest")
proto.RegisterType((*CreateTaskResponse)(nil), "containerd.services.tasks.v1.CreateTaskResponse")
@ -410,6 +420,7 @@ func init() {
proto.RegisterType((*ListProcessesResponse)(nil), "containerd.services.tasks.v1.ListProcessesResponse")
proto.RegisterType((*CheckpointTaskRequest)(nil), "containerd.services.tasks.v1.CheckpointTaskRequest")
proto.RegisterType((*CheckpointTaskResponse)(nil), "containerd.services.tasks.v1.CheckpointTaskResponse")
proto.RegisterType((*UpdateTaskRequest)(nil), "containerd.services.tasks.v1.UpdateTaskRequest")
}
// Reference imports to suppress errors if they are not otherwise used.
@ -441,6 +452,7 @@ type TasksClient interface {
Resume(ctx context.Context, in *ResumeTaskRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
ListProcesses(ctx context.Context, in *ListProcessesRequest, opts ...grpc.CallOption) (*ListProcessesResponse, error)
Checkpoint(ctx context.Context, in *CheckpointTaskRequest, opts ...grpc.CallOption) (*CheckpointTaskResponse, error)
Update(ctx context.Context, in *UpdateTaskRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
}
type tasksClient struct {
@ -577,6 +589,15 @@ func (c *tasksClient) Checkpoint(ctx context.Context, in *CheckpointTaskRequest,
return out, nil
}
func (c *tasksClient) Update(ctx context.Context, in *UpdateTaskRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
out := new(google_protobuf.Empty)
err := grpc.Invoke(ctx, "/containerd.services.tasks.v1.Tasks/Update", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for Tasks service
type TasksServer interface {
@ -598,6 +619,7 @@ type TasksServer interface {
Resume(context.Context, *ResumeTaskRequest) (*google_protobuf.Empty, error)
ListProcesses(context.Context, *ListProcessesRequest) (*ListProcessesResponse, error)
Checkpoint(context.Context, *CheckpointTaskRequest) (*CheckpointTaskResponse, error)
Update(context.Context, *UpdateTaskRequest) (*google_protobuf.Empty, error)
}
func RegisterTasksServer(s *grpc.Server, srv TasksServer) {
@ -856,6 +878,24 @@ func _Tasks_Checkpoint_Handler(srv interface{}, ctx context.Context, dec func(in
return interceptor(ctx, in, info, handler)
}
func _Tasks_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(UpdateTaskRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(TasksServer).Update(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.services.tasks.v1.Tasks/Update",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(TasksServer).Update(ctx, req.(*UpdateTaskRequest))
}
return interceptor(ctx, in, info, handler)
}
var _Tasks_serviceDesc = grpc.ServiceDesc{
ServiceName: "containerd.services.tasks.v1.Tasks",
HandlerType: (*TasksServer)(nil),
@ -916,6 +956,10 @@ var _Tasks_serviceDesc = grpc.ServiceDesc{
MethodName: "Checkpoint",
Handler: _Tasks_Checkpoint_Handler,
},
{
MethodName: "Update",
Handler: _Tasks_Update_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "github.com/containerd/containerd/api/services/tasks/v1/tasks.proto",
@ -1646,6 +1690,40 @@ func (m *CheckpointTaskResponse) MarshalTo(dAtA []byte) (int, error) {
return i, nil
}
func (m *UpdateTaskRequest) 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 *UpdateTaskRequest) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.ContainerID) > 0 {
dAtA[i] = 0xa
i++
i = encodeVarintTasks(dAtA, i, uint64(len(m.ContainerID)))
i += copy(dAtA[i:], m.ContainerID)
}
if m.Resources != nil {
dAtA[i] = 0x12
i++
i = encodeVarintTasks(dAtA, i, uint64(m.Resources.Size()))
n6, err := m.Resources.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n6
}
return i, nil
}
func encodeFixed64Tasks(dAtA []byte, offset int, v uint64) int {
dAtA[offset] = uint8(v)
dAtA[offset+1] = uint8(v >> 8)
@ -1991,6 +2069,20 @@ func (m *CheckpointTaskResponse) Size() (n int) {
return n
}
func (m *UpdateTaskRequest) Size() (n int) {
var l int
_ = l
l = len(m.ContainerID)
if l > 0 {
n += 1 + l + sovTasks(uint64(l))
}
if m.Resources != nil {
l = m.Resources.Size()
n += 1 + l + sovTasks(uint64(l))
}
return n
}
func sovTasks(x uint64) (n int) {
for {
n++
@ -2269,6 +2361,17 @@ func (this *CheckpointTaskResponse) String() string {
}, "")
return s
}
func (this *UpdateTaskRequest) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&UpdateTaskRequest{`,
`ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`,
`Resources:` + strings.Replace(fmt.Sprintf("%v", this.Resources), "Any", "google_protobuf1.Any", 1) + `,`,
`}`,
}, "")
return s
}
func valueToStringTasks(v interface{}) string {
rv := reflect.ValueOf(v)
if rv.IsNil() {
@ -4654,6 +4757,118 @@ func (m *CheckpointTaskResponse) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *UpdateTaskRequest) 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 ErrIntOverflowTasks
}
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: UpdateTaskRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: UpdateTaskRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTasks
}
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 ErrInvalidLengthTasks
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.ContainerID = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTasks
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthTasks
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Resources == nil {
m.Resources = &google_protobuf1.Any{}
}
if err := m.Resources.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipTasks(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthTasks
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipTasks(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0
@ -4764,80 +4979,82 @@ func init() {
}
var fileDescriptorTasks = []byte{
// 1191 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0xcf, 0x4f, 0xe3, 0xc6,
0x17, 0xc7, 0xf9, 0xb5, 0xe1, 0x05, 0x58, 0x98, 0x2f, 0xcb, 0x37, 0xeb, 0xa2, 0x04, 0xf9, 0xd2,
0x74, 0x55, 0xec, 0x12, 0xaa, 0xaa, 0x62, 0x57, 0xd5, 0x02, 0xa1, 0x94, 0xfe, 0x10, 0xd4, 0xac,
0xaa, 0x0a, 0x55, 0x8a, 0x4c, 0x3c, 0x84, 0x51, 0x1c, 0xdb, 0xeb, 0x99, 0xb0, 0xa4, 0xa7, 0x9e,
0x7a, 0x6d, 0x8f, 0xfd, 0x5b, 0x7a, 0xee, 0x81, 0x63, 0x0f, 0x3d, 0x54, 0x3d, 0xd0, 0x2e, 0xfd,
0x47, 0xaa, 0x19, 0x4f, 0x8c, 0x93, 0x90, 0x5f, 0x84, 0x0b, 0xcc, 0x3c, 0xbf, 0xf7, 0xe6, 0xfd,
0xfe, 0x3c, 0x05, 0x76, 0xea, 0x84, 0x9d, 0xb7, 0x4e, 0xf5, 0x9a, 0xd7, 0x34, 0x6a, 0x9e, 0xcb,
0x2c, 0xe2, 0xe2, 0xc0, 0x8e, 0x1f, 0x2d, 0x9f, 0x18, 0x14, 0x07, 0x17, 0xa4, 0x86, 0xa9, 0xc1,
0x2c, 0xda, 0xa0, 0xc6, 0xc5, 0x46, 0x78, 0xd0, 0xfd, 0xc0, 0x63, 0x1e, 0x5a, 0xbd, 0xe5, 0xd6,
0x3b, 0x9c, 0x7a, 0xc8, 0x70, 0xb1, 0xa1, 0xbe, 0x53, 0xf7, 0xbc, 0xba, 0x83, 0x0d, 0xc1, 0x7b,
0xda, 0x3a, 0x33, 0x70, 0xd3, 0x67, 0xed, 0x50, 0x54, 0x7d, 0xda, 0xfb, 0xd1, 0x72, 0x3b, 0x9f,
0x96, 0xeb, 0x5e, 0xdd, 0x13, 0x47, 0x83, 0x9f, 0x24, 0xf5, 0xa3, 0xb1, 0xec, 0x65, 0x6d, 0x1f,
0x53, 0xa3, 0xe9, 0xb5, 0x5c, 0x26, 0xe5, 0x9e, 0x4f, 0x20, 0x67, 0x63, 0x5a, 0x0b, 0x88, 0xcf,
0xbc, 0x40, 0x0a, 0x6f, 0x4d, 0x20, 0xcc, 0xfd, 0x16, 0x7f, 0xa4, 0x6c, 0xb1, 0xd7, 0x43, 0x46,
0x9a, 0x98, 0x32, 0xab, 0xe9, 0x87, 0x0c, 0xda, 0x2f, 0x09, 0x58, 0xda, 0x0d, 0xb0, 0xc5, 0xf0,
0x2b, 0x8b, 0x36, 0x4c, 0xfc, 0xba, 0x85, 0x29, 0x43, 0x65, 0x98, 0x8b, 0xd4, 0x57, 0x89, 0x9d,
0x4f, 0xac, 0x29, 0xa5, 0xd9, 0x9d, 0xc7, 0x37, 0xd7, 0xc5, 0xdc, 0x6e, 0x87, 0x7e, 0x50, 0x31,
0x73, 0x11, 0xd3, 0x81, 0x8d, 0x0c, 0xc8, 0x04, 0x9e, 0xc7, 0xce, 0x68, 0x3e, 0xb9, 0x96, 0x2c,
0xe5, 0xca, 0xff, 0xd7, 0x63, 0x89, 0x11, 0xd6, 0xe9, 0x5f, 0xf1, 0x90, 0x98, 0x92, 0x0d, 0x2d,
0x43, 0x9a, 0x32, 0x9b, 0xb8, 0xf9, 0x14, 0xd7, 0x6e, 0x86, 0x17, 0xb4, 0x02, 0x19, 0xca, 0x6c,
0xaf, 0xc5, 0xf2, 0x69, 0x41, 0x96, 0x37, 0x49, 0xc7, 0x41, 0x90, 0xcf, 0x44, 0x74, 0x1c, 0x04,
0x48, 0x85, 0x2c, 0xc3, 0x41, 0x93, 0xb8, 0x96, 0x93, 0x7f, 0xb4, 0xa6, 0x94, 0xb2, 0x66, 0x74,
0x47, 0x2f, 0x00, 0x6a, 0xe7, 0xb8, 0xd6, 0xf0, 0x3d, 0xe2, 0xb2, 0x7c, 0x76, 0x4d, 0x29, 0xe5,
0xca, 0xab, 0xfd, 0x66, 0x55, 0xa2, 0x88, 0x9b, 0x31, 0x7e, 0xed, 0x04, 0x50, 0x3c, 0x32, 0xd4,
0xf7, 0x5c, 0x8a, 0xef, 0x15, 0x9a, 0x45, 0x48, 0xfa, 0xc4, 0xce, 0x27, 0xd7, 0x94, 0xd2, 0xbc,
0xc9, 0x8f, 0xda, 0xa7, 0xb0, 0x78, 0xcc, 0xac, 0x80, 0x0d, 0x0b, 0xba, 0x32, 0x5a, 0xb3, 0xb6,
0x0f, 0x4b, 0x15, 0xec, 0xe0, 0xe1, 0xd9, 0x1b, 0x47, 0xd1, 0xaf, 0x0a, 0x2c, 0x84, 0x9a, 0x06,
0x7a, 0xaa, 0x8c, 0xef, 0x69, 0x22, 0xf2, 0x14, 0x15, 0x21, 0x87, 0x2f, 0x09, 0xab, 0x52, 0x66,
0xb1, 0x16, 0x95, 0x31, 0x00, 0x4e, 0x3a, 0x16, 0x14, 0xb4, 0x0d, 0xb3, 0xfc, 0x86, 0xed, 0xaa,
0xc5, 0x44, 0x29, 0xe4, 0xca, 0xaa, 0x1e, 0x96, 0xad, 0xde, 0x29, 0x5b, 0xfd, 0x55, 0xa7, 0x6c,
0x77, 0xb2, 0x57, 0xd7, 0xc5, 0x99, 0x9f, 0xff, 0x2e, 0x2a, 0x66, 0x36, 0x14, 0xdb, 0x66, 0xda,
0x77, 0xb0, 0x1c, 0xda, 0x7e, 0x14, 0x78, 0x35, 0x4c, 0xe9, 0x14, 0x81, 0xe8, 0xf7, 0x40, 0xab,
0xc0, 0xc2, 0x3e, 0x9e, 0x3a, 0x53, 0x2f, 0xe1, 0x71, 0xa4, 0x45, 0x06, 0x78, 0x1d, 0x52, 0xbc,
0x55, 0x85, 0x78, 0xae, 0xfc, 0x34, 0x5e, 0x98, 0x17, 0x1b, 0xb2, 0x36, 0x85, 0x80, 0x60, 0xd3,
0x9e, 0xc1, 0xe2, 0x97, 0x84, 0x0a, 0x15, 0x91, 0x87, 0x2b, 0x90, 0x39, 0x23, 0x0e, 0xc3, 0x41,
0x68, 0x83, 0x29, 0x6f, 0x5a, 0x05, 0x96, 0x62, 0xbc, 0xf2, 0x3d, 0x03, 0xd2, 0x62, 0x2e, 0xe6,
0x15, 0xd1, 0xa0, 0x43, 0x1e, 0x0c, 0xf9, 0xb4, 0x9f, 0x14, 0xc8, 0x7d, 0x41, 0x1c, 0x67, 0x9a,
0x78, 0xf2, 0xbe, 0x25, 0x75, 0xde, 0x9d, 0x61, 0x48, 0xe5, 0x0d, 0x21, 0x48, 0x5a, 0x8e, 0x23,
0xea, 0x21, 0xfb, 0xd9, 0x8c, 0xc9, 0x2f, 0x9c, 0xc6, 0x63, 0xcf, 0x8b, 0x60, 0x9e, 0xd3, 0x7c,
0x62, 0xef, 0xcc, 0x01, 0xf8, 0xc4, 0xae, 0x7a, 0x41, 0xd5, 0x72, 0x1c, 0xed, 0x0f, 0x05, 0xd0,
0xde, 0x25, 0xae, 0x3d, 0x40, 0xa2, 0xa3, 0xf1, 0x93, 0xb8, 0x7b, 0xfc, 0x24, 0x07, 0x8c, 0x9f,
0xd4, 0xc0, 0xf1, 0x93, 0xee, 0x19, 0x3f, 0x25, 0x48, 0x51, 0x1f, 0xd7, 0xc4, 0xc0, 0xca, 0x95,
0x97, 0xfb, 0x8a, 0x7a, 0xdb, 0x6d, 0x9b, 0x82, 0x43, 0x7b, 0x17, 0xfe, 0xd7, 0xe5, 0x95, 0x4c,
0x98, 0xac, 0x45, 0xe5, 0xb6, 0x16, 0x7f, 0x54, 0x60, 0xd1, 0xc4, 0x94, 0x7c, 0x8f, 0x8f, 0x58,
0xfb, 0x41, 0xcb, 0x9c, 0xc7, 0xe3, 0x0d, 0xb1, 0xd9, 0xb9, 0x6c, 0xd1, 0xf0, 0xc2, 0xfd, 0x3e,
0xc7, 0xa4, 0x7e, 0x1e, 0xb6, 0xe6, 0xbc, 0x29, 0x6f, 0x9a, 0x03, 0x0b, 0xbb, 0x8e, 0x47, 0xf1,
0xc1, 0xe1, 0x83, 0x5b, 0x11, 0x66, 0x45, 0x14, 0x86, 0xcc, 0x0a, 0x1f, 0x97, 0x47, 0x56, 0x8b,
0xe2, 0x07, 0x18, 0x97, 0x26, 0xa6, 0xad, 0xe6, 0xd4, 0x8a, 0x3e, 0x87, 0x65, 0xde, 0x5f, 0x32,
0x61, 0x78, 0x9a, 0x42, 0xd4, 0x8e, 0xe1, 0x49, 0x8f, 0x2e, 0x99, 0xfe, 0x2d, 0x98, 0xf5, 0x3b,
0x44, 0xd9, 0xb3, 0xab, 0x77, 0xf6, 0x6c, 0xa7, 0x6e, 0x6e, 0xd9, 0xb5, 0xdf, 0x12, 0xf0, 0x64,
0x37, 0xc2, 0xb2, 0x29, 0xdd, 0x45, 0x55, 0x58, 0xf2, 0xad, 0x00, 0xbb, 0xac, 0x1a, 0xc3, 0xd3,
0x10, 0xf9, 0xca, 0x7c, 0x1e, 0xff, 0x75, 0x5d, 0x7c, 0x16, 0xdb, 0x52, 0x3c, 0x1f, 0xbb, 0x91,
0x38, 0x35, 0xea, 0xde, 0xba, 0x4d, 0xea, 0x98, 0x32, 0xbd, 0x22, 0xfe, 0x99, 0x8b, 0xa1, 0xb2,
0x5b, 0xfb, 0xd0, 0x09, 0x3c, 0xf2, 0x7c, 0x46, 0x3c, 0xb7, 0xb3, 0x3d, 0xbc, 0xd4, 0x87, 0xad,
0x75, 0xfa, 0x9d, 0xae, 0xe9, 0x87, 0xa1, 0x8a, 0x3d, 0x97, 0x05, 0x6d, 0xb3, 0xa3, 0x50, 0xdd,
0x82, 0xb9, 0xf8, 0x07, 0x5e, 0x74, 0x0d, 0xdc, 0x96, 0x03, 0x93, 0x1f, 0x79, 0xd1, 0x5d, 0x58,
0x4e, 0x0b, 0x77, 0x46, 0x81, 0xb8, 0x6c, 0x25, 0x3e, 0x56, 0xb4, 0x6f, 0x61, 0xa5, 0xf7, 0x29,
0x99, 0x9c, 0x4f, 0x20, 0x77, 0xbb, 0xa9, 0xdd, 0x99, 0x9e, 0xbe, 0xe5, 0x22, 0x2e, 0x50, 0xfe,
0x17, 0x20, 0x2d, 0xc6, 0x33, 0x6a, 0x40, 0x26, 0xdc, 0x33, 0x90, 0x31, 0xc2, 0xe9, 0xde, 0x3d,
0x4d, 0xfd, 0x60, 0x7c, 0x01, 0x69, 0xf6, 0x21, 0xa4, 0xc5, 0xe2, 0x81, 0xf4, 0xe1, 0xa2, 0xbd,
0xdb, 0x89, 0xba, 0xd2, 0x37, 0xbe, 0xf6, 0xf8, 0x26, 0x8d, 0xea, 0x90, 0x09, 0xb1, 0x77, 0x94,
0xf5, 0x7d, 0x7b, 0x8a, 0xfa, 0xfe, 0x38, 0x02, 0x91, 0xe5, 0xaf, 0x61, 0xbe, 0x0b, 0xe4, 0x51,
0x79, 0x1c, 0xf1, 0x6e, 0xa0, 0x98, 0xf0, 0xc9, 0x53, 0x48, 0xee, 0x63, 0x86, 0x46, 0x08, 0x75,
0x2f, 0x07, 0xea, 0xfa, 0x98, 0xdc, 0xf2, 0x8d, 0x3a, 0xa4, 0x78, 0xf7, 0x8f, 0xca, 0x47, 0x2f,
0xf2, 0xab, 0xc6, 0xd8, 0xfc, 0xf2, 0xa1, 0x03, 0x48, 0x71, 0x2c, 0x47, 0xef, 0x0d, 0x17, 0x8c,
0xe1, 0xfd, 0xc0, 0x9c, 0x37, 0x20, 0xc5, 0xe1, 0x0a, 0x8d, 0x28, 0xbf, 0x7e, 0xa0, 0x56, 0x37,
0x26, 0x90, 0x90, 0x76, 0x1f, 0xc3, 0x6c, 0x84, 0x78, 0xa3, 0xa2, 0xd4, 0x0b, 0x8d, 0x03, 0x3d,
0x38, 0x84, 0x47, 0x12, 0xbe, 0x46, 0x65, 0xb7, 0x1b, 0xe5, 0x86, 0x28, 0x4c, 0x0b, 0x84, 0x1a,
0x65, 0x61, 0x2f, 0x8c, 0x0d, 0x54, 0xf8, 0x35, 0x64, 0x42, 0xa8, 0x1a, 0xd5, 0x57, 0x7d, 0x80,
0x36, 0x50, 0xe5, 0x25, 0xcc, 0x77, 0x01, 0xcd, 0xa8, 0x0e, 0xba, 0x0b, 0xe1, 0xd4, 0xcd, 0x89,
0x64, 0x64, 0x0e, 0xdf, 0x00, 0xc4, 0x86, 0xfd, 0xe6, 0x3d, 0x66, 0xbb, 0xfa, 0xe1, 0x64, 0x42,
0xe1, 0xc3, 0x3b, 0xdf, 0x5c, 0xbd, 0x2d, 0xcc, 0xfc, 0xf9, 0xb6, 0x30, 0xf3, 0xc3, 0x4d, 0x41,
0xb9, 0xba, 0x29, 0x28, 0xbf, 0xdf, 0x14, 0x94, 0x7f, 0x6e, 0x0a, 0xca, 0xc9, 0x8b, 0xfb, 0xfd,
0xf4, 0xf0, 0x5c, 0x1c, 0x4e, 0x33, 0x22, 0xb4, 0x9b, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0xf2,
0x10, 0x7d, 0xd7, 0xc1, 0x10, 0x00, 0x00,
// 1231 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0xcd, 0x4f, 0xe3, 0x46,
0x14, 0xc7, 0xf9, 0xda, 0xf0, 0x02, 0x2c, 0x4c, 0x59, 0x9a, 0x75, 0x51, 0x82, 0x7c, 0x69, 0xba,
0x2a, 0x76, 0x09, 0x55, 0x55, 0xb1, 0xab, 0x6a, 0x81, 0x50, 0x4a, 0x3f, 0x04, 0x6b, 0xb6, 0x55,
0x85, 0x2a, 0x45, 0x26, 0x1e, 0x82, 0x15, 0xc7, 0xf6, 0x7a, 0x26, 0x2c, 0x69, 0x2f, 0x3d, 0xf5,
0xda, 0x1e, 0xfb, 0x97, 0xf4, 0xd0, 0x73, 0x0f, 0x1c, 0x7b, 0xe8, 0xa1, 0xea, 0x81, 0x76, 0xf9,
0x4b, 0xaa, 0x19, 0x4f, 0x1c, 0x27, 0x21, 0x71, 0x42, 0xb8, 0xc0, 0xcc, 0xf3, 0x7b, 0x6f, 0xde,
0xf7, 0xef, 0x29, 0xb0, 0x53, 0xb7, 0xe8, 0x79, 0xeb, 0x54, 0xad, 0xb9, 0x4d, 0xad, 0xe6, 0x3a,
0xd4, 0xb0, 0x1c, 0xec, 0x9b, 0xd1, 0xa3, 0xe1, 0x59, 0x1a, 0xc1, 0xfe, 0x85, 0x55, 0xc3, 0x44,
0xa3, 0x06, 0x69, 0x10, 0xed, 0x62, 0x23, 0x38, 0xa8, 0x9e, 0xef, 0x52, 0x17, 0xad, 0x76, 0xb9,
0xd5, 0x0e, 0xa7, 0x1a, 0x30, 0x5c, 0x6c, 0xc8, 0xef, 0xd4, 0x5d, 0xb7, 0x6e, 0x63, 0x8d, 0xf3,
0x9e, 0xb6, 0xce, 0x34, 0xdc, 0xf4, 0x68, 0x3b, 0x10, 0x95, 0x1f, 0xf7, 0x7f, 0x34, 0x9c, 0xce,
0xa7, 0xe5, 0xba, 0x5b, 0x77, 0xf9, 0x51, 0x63, 0x27, 0x41, 0xfd, 0x68, 0x2c, 0x7b, 0x69, 0xdb,
0xc3, 0x44, 0x6b, 0xba, 0x2d, 0x87, 0x0a, 0xb9, 0xa7, 0x13, 0xc8, 0x99, 0x98, 0xd4, 0x7c, 0xcb,
0xa3, 0xae, 0x2f, 0x84, 0xb7, 0x26, 0x10, 0x66, 0x7e, 0xf3, 0x3f, 0x42, 0xb6, 0xd8, 0xef, 0x21,
0xb5, 0x9a, 0x98, 0x50, 0xa3, 0xe9, 0x05, 0x0c, 0xca, 0xaf, 0x09, 0x58, 0xda, 0xf5, 0xb1, 0x41,
0xf1, 0x4b, 0x83, 0x34, 0x74, 0xfc, 0xaa, 0x85, 0x09, 0x45, 0x65, 0x98, 0x0b, 0xd5, 0x57, 0x2d,
0x33, 0x9f, 0x58, 0x93, 0x4a, 0xb3, 0x3b, 0x0f, 0x6f, 0xae, 0x8b, 0xb9, 0xdd, 0x0e, 0xfd, 0xa0,
0xa2, 0xe7, 0x42, 0xa6, 0x03, 0x13, 0x69, 0x90, 0xf1, 0x5d, 0x97, 0x9e, 0x91, 0x7c, 0x72, 0x2d,
0x59, 0xca, 0x95, 0xdf, 0x56, 0x23, 0x89, 0xe1, 0xd6, 0xa9, 0x5f, 0xb1, 0x90, 0xe8, 0x82, 0x0d,
0x2d, 0x43, 0x9a, 0x50, 0xd3, 0x72, 0xf2, 0x29, 0xa6, 0x5d, 0x0f, 0x2e, 0x68, 0x05, 0x32, 0x84,
0x9a, 0x6e, 0x8b, 0xe6, 0xd3, 0x9c, 0x2c, 0x6e, 0x82, 0x8e, 0x7d, 0x3f, 0x9f, 0x09, 0xe9, 0xd8,
0xf7, 0x91, 0x0c, 0x59, 0x8a, 0xfd, 0xa6, 0xe5, 0x18, 0x76, 0xfe, 0xc1, 0x9a, 0x54, 0xca, 0xea,
0xe1, 0x1d, 0x3d, 0x03, 0xa8, 0x9d, 0xe3, 0x5a, 0xc3, 0x73, 0x2d, 0x87, 0xe6, 0xb3, 0x6b, 0x52,
0x29, 0x57, 0x5e, 0x1d, 0x34, 0xab, 0x12, 0x46, 0x5c, 0x8f, 0xf0, 0x2b, 0x27, 0x80, 0xa2, 0x91,
0x21, 0x9e, 0xeb, 0x10, 0x7c, 0xa7, 0xd0, 0x2c, 0x42, 0xd2, 0xb3, 0xcc, 0x7c, 0x72, 0x4d, 0x2a,
0xcd, 0xeb, 0xec, 0xa8, 0x7c, 0x0a, 0x8b, 0xc7, 0xd4, 0xf0, 0xe9, 0xa8, 0xa0, 0x4b, 0xf1, 0x9a,
0x95, 0x7d, 0x58, 0xaa, 0x60, 0x1b, 0x8f, 0xce, 0xde, 0x38, 0x8a, 0x7e, 0x97, 0x60, 0x21, 0xd0,
0x34, 0xd4, 0x53, 0x69, 0x7c, 0x4f, 0x13, 0xa1, 0xa7, 0xa8, 0x08, 0x39, 0x7c, 0x69, 0xd1, 0x2a,
0xa1, 0x06, 0x6d, 0x11, 0x11, 0x03, 0x60, 0xa4, 0x63, 0x4e, 0x41, 0xdb, 0x30, 0xcb, 0x6e, 0xd8,
0xac, 0x1a, 0x94, 0x97, 0x42, 0xae, 0x2c, 0xab, 0x41, 0xd9, 0xaa, 0x9d, 0xb2, 0x55, 0x5f, 0x76,
0xca, 0x76, 0x27, 0x7b, 0x75, 0x5d, 0x9c, 0xf9, 0xe5, 0xdf, 0xa2, 0xa4, 0x67, 0x03, 0xb1, 0x6d,
0xaa, 0x7c, 0x07, 0xcb, 0x81, 0xed, 0x47, 0xbe, 0x5b, 0xc3, 0x84, 0x4c, 0x11, 0x88, 0x41, 0x0f,
0x94, 0x0a, 0x2c, 0xec, 0xe3, 0xa9, 0x33, 0xf5, 0x1c, 0x1e, 0x86, 0x5a, 0x44, 0x80, 0xd7, 0x21,
0xc5, 0x5a, 0x95, 0x8b, 0xe7, 0xca, 0x8f, 0xa3, 0x85, 0x79, 0xb1, 0x21, 0x6a, 0x93, 0x0b, 0x70,
0x36, 0xe5, 0x09, 0x2c, 0x7e, 0x69, 0x11, 0xae, 0x22, 0xf4, 0x70, 0x05, 0x32, 0x67, 0x96, 0x4d,
0xb1, 0x1f, 0xd8, 0xa0, 0x8b, 0x9b, 0x52, 0x81, 0xa5, 0x08, 0xaf, 0x78, 0x4f, 0x83, 0x34, 0x9f,
0x8b, 0x79, 0x89, 0x37, 0xe8, 0x88, 0x07, 0x03, 0x3e, 0xe5, 0x67, 0x09, 0x72, 0x5f, 0x58, 0xb6,
0x3d, 0x4d, 0x3c, 0x59, 0xdf, 0x5a, 0x75, 0xd6, 0x9d, 0x41, 0x48, 0xc5, 0x0d, 0x21, 0x48, 0x1a,
0xb6, 0xcd, 0xeb, 0x21, 0xfb, 0xd9, 0x8c, 0xce, 0x2e, 0x8c, 0xc6, 0x62, 0xcf, 0x8a, 0x60, 0x9e,
0xd1, 0x3c, 0xcb, 0xdc, 0x99, 0x03, 0xf0, 0x2c, 0xb3, 0xea, 0xfa, 0x55, 0xc3, 0xb6, 0x95, 0xbf,
0x24, 0x40, 0x7b, 0x97, 0xb8, 0x76, 0x0f, 0x89, 0x0e, 0xc7, 0x4f, 0xe2, 0xf6, 0xf1, 0x93, 0x1c,
0x32, 0x7e, 0x52, 0x43, 0xc7, 0x4f, 0xba, 0x6f, 0xfc, 0x94, 0x20, 0x45, 0x3c, 0x5c, 0xe3, 0x03,
0x2b, 0x57, 0x5e, 0x1e, 0x28, 0xea, 0x6d, 0xa7, 0xad, 0x73, 0x0e, 0xe5, 0x5d, 0x78, 0xab, 0xc7,
0x2b, 0x91, 0x30, 0x51, 0x8b, 0x52, 0xb7, 0x16, 0x7f, 0x92, 0x60, 0x51, 0xc7, 0xc4, 0xfa, 0x1e,
0x1f, 0xd1, 0xf6, 0xbd, 0x96, 0x39, 0x8b, 0xc7, 0x6b, 0xcb, 0xa4, 0xe7, 0xa2, 0x45, 0x83, 0x0b,
0xf3, 0xfb, 0x1c, 0x5b, 0xf5, 0xf3, 0xa0, 0x35, 0xe7, 0x75, 0x71, 0x53, 0x6c, 0x58, 0xd8, 0xb5,
0x5d, 0x82, 0x0f, 0x0e, 0xef, 0xdd, 0x8a, 0x20, 0x2b, 0xbc, 0x30, 0x44, 0x56, 0xd8, 0xb8, 0x3c,
0x32, 0x5a, 0x04, 0xdf, 0xc3, 0xb8, 0xd4, 0x31, 0x69, 0x35, 0xa7, 0x56, 0xf4, 0x39, 0x2c, 0xb3,
0xfe, 0x12, 0x09, 0xc3, 0xd3, 0x14, 0xa2, 0x72, 0x0c, 0x8f, 0xfa, 0x74, 0x89, 0xf4, 0x6f, 0xc1,
0xac, 0xd7, 0x21, 0x8a, 0x9e, 0x5d, 0xbd, 0xb5, 0x67, 0x3b, 0x75, 0xd3, 0x65, 0x57, 0xfe, 0x48,
0xc0, 0xa3, 0xdd, 0x10, 0xcb, 0xa6, 0x74, 0x17, 0x55, 0x61, 0xc9, 0x33, 0x7c, 0xec, 0xd0, 0x6a,
0x04, 0x4f, 0x03, 0xe4, 0x2b, 0xb3, 0x79, 0xfc, 0xcf, 0x75, 0xf1, 0x49, 0x64, 0x4b, 0x71, 0x3d,
0xec, 0x84, 0xe2, 0x44, 0xab, 0xbb, 0xeb, 0xa6, 0x55, 0xc7, 0x84, 0xaa, 0x15, 0xfe, 0x4f, 0x5f,
0x0c, 0x94, 0x75, 0xed, 0x43, 0x27, 0xf0, 0xc0, 0xf5, 0xa8, 0xe5, 0x3a, 0x9d, 0xed, 0xe1, 0xb9,
0x3a, 0x6a, 0xad, 0x53, 0x6f, 0x75, 0x4d, 0x3d, 0x0c, 0x54, 0xec, 0x39, 0xd4, 0x6f, 0xeb, 0x1d,
0x85, 0xf2, 0x16, 0xcc, 0x45, 0x3f, 0xb0, 0xa2, 0x6b, 0xe0, 0xb6, 0x18, 0x98, 0xec, 0xc8, 0x8a,
0xee, 0xc2, 0xb0, 0x5b, 0xb8, 0x33, 0x0a, 0xf8, 0x65, 0x2b, 0xf1, 0xb1, 0xa4, 0x7c, 0x0b, 0x2b,
0xfd, 0x4f, 0x89, 0xe4, 0x7c, 0x02, 0xb9, 0xee, 0xa6, 0x76, 0x6b, 0x7a, 0x06, 0x96, 0x8b, 0xa8,
0x80, 0xf2, 0x03, 0x2c, 0x7d, 0xed, 0x99, 0xc6, 0xd4, 0xc8, 0x8d, 0xca, 0x30, 0xeb, 0x63, 0xe2,
0xb6, 0xfc, 0x1a, 0x26, 0xdc, 0x81, 0x61, 0xa3, 0xa6, 0xcb, 0x56, 0xfe, 0x2d, 0x07, 0x69, 0x8e,
0x0d, 0xa8, 0x01, 0x99, 0x60, 0xc9, 0x41, 0x5a, 0x4c, 0xc4, 0xfb, 0x97, 0x44, 0xf9, 0x83, 0xf1,
0x05, 0x44, 0xcc, 0x0e, 0x21, 0xcd, 0xb7, 0x1e, 0xa4, 0x8e, 0x16, 0xed, 0x5f, 0x8d, 0xe4, 0x95,
0x01, 0x87, 0xf6, 0xd8, 0x1a, 0x8f, 0xea, 0x90, 0x09, 0x80, 0x3f, 0xce, 0xfa, 0x81, 0x25, 0x49,
0x7e, 0x7f, 0x1c, 0x81, 0xd0, 0xf2, 0x57, 0x30, 0xdf, 0xb3, 0x61, 0xa0, 0xf2, 0x38, 0xe2, 0xbd,
0x28, 0x35, 0xe1, 0x93, 0xa7, 0x90, 0xdc, 0xc7, 0x14, 0xc5, 0x08, 0xf5, 0x6e, 0x26, 0xf2, 0xfa,
0x98, 0xdc, 0xe2, 0x8d, 0x3a, 0xa4, 0xd8, 0xe8, 0x89, 0xcb, 0x47, 0xff, 0xda, 0x21, 0x6b, 0x63,
0xf3, 0x8b, 0x87, 0x0e, 0x20, 0xc5, 0x16, 0x09, 0xf4, 0xde, 0x68, 0xc1, 0xc8, 0xb2, 0x31, 0x34,
0xe7, 0x0d, 0x48, 0x31, 0xac, 0x44, 0x31, 0xe5, 0x37, 0xb8, 0x25, 0xc8, 0x1b, 0x13, 0x48, 0x08,
0xbb, 0x8f, 0x61, 0x36, 0x84, 0xdb, 0xb8, 0x28, 0xf5, 0xe3, 0xf2, 0x50, 0x0f, 0x0e, 0xe1, 0x81,
0xc0, 0xce, 0xb8, 0xec, 0xf6, 0x42, 0xec, 0x08, 0x85, 0x69, 0x0e, 0x8f, 0x71, 0x16, 0xf6, 0x63,
0xe8, 0x50, 0x85, 0x2f, 0x20, 0x13, 0xe0, 0x64, 0x5c, 0x5f, 0x0d, 0xa0, 0xe9, 0x50, 0x95, 0x97,
0x30, 0xdf, 0x83, 0x72, 0x71, 0x1d, 0x74, 0x1b, 0xbc, 0xca, 0x9b, 0x13, 0xc9, 0x88, 0x1c, 0xbe,
0x06, 0x88, 0x20, 0xcd, 0xe6, 0x1d, 0x80, 0x45, 0xfe, 0x70, 0x32, 0x21, 0xf1, 0xf0, 0x0b, 0xc8,
0x04, 0x23, 0x3e, 0x2e, 0x8a, 0x03, 0x40, 0x30, 0x2c, 0x8a, 0x3b, 0xdf, 0x5c, 0xbd, 0x29, 0xcc,
0xfc, 0xfd, 0xa6, 0x30, 0xf3, 0xe3, 0x4d, 0x41, 0xba, 0xba, 0x29, 0x48, 0x7f, 0xde, 0x14, 0xa4,
0xff, 0x6e, 0x0a, 0xd2, 0xc9, 0xb3, 0xbb, 0xfd, 0x94, 0xf2, 0x94, 0x1f, 0x4e, 0x33, 0xfc, 0x9d,
0xcd, 0xff, 0x03, 0x00, 0x00, 0xff, 0xff, 0x1a, 0x9f, 0x9a, 0x26, 0x91, 0x11, 0x00, 0x00,
}

7
api/services/tasks/v1/tasks.proto
View File

@ -44,6 +44,8 @@ service Tasks {
rpc ListProcesses(ListProcessesRequest) returns (ListProcessesResponse);
rpc Checkpoint(CheckpointTaskRequest) returns (CheckpointTaskResponse);
rpc Update(UpdateTaskRequest) returns (google.protobuf.Empty);
}
message CreateTaskRequest {
@ -188,3 +190,8 @@ message CheckpointTaskRequest {
message CheckpointTaskResponse {
repeated containerd.types.Descriptor descriptors = 1;
}
message UpdateTaskRequest {
string container_id = 1;
google.protobuf.Any resources = 2;
}

95
container_test.go
View File

@ -9,6 +9,9 @@ import (
"sync"
"syscall"
"testing"
"github.com/containerd/cgroups"
specs "github.com/opencontainers/runtime-spec/specs-go"
)
func empty() IOCreation {
@ -734,3 +737,95 @@ func TestContainerKill(t *testing.T) {
t.Errorf("expected error %q but received %q", ErrProcessExited, err)
}
}
func TestContainerUpdate(t *testing.T) {
if testing.Short() {
t.Skip()
}
client, err := New(address)
if err != nil {
t.Fatal(err)
}
defer client.Close()
var (
ctx, cancel = testContext()
id = t.Name()
)
defer cancel()
image, err := client.GetImage(ctx, testImage)
if err != nil {
t.Error(err)
return
}
spec, err := GenerateSpec(WithImageConfig(ctx, image), WithProcessArgs("sleep", "30"))
if err != nil {
t.Error(err)
return
}
limit := uint64(32 * 1024 * 1024)
spec.Linux.Resources.Memory = &specs.LinuxMemory{
Limit: &limit,
}
container, err := client.NewContainer(ctx, id, WithSpec(spec), WithNewRootFS(id, image))
if err != nil {
t.Error(err)
return
}
defer container.Delete(ctx, WithRootFSDeletion)
task, err := container.NewTask(ctx, empty())
if err != nil {
t.Error(err)
return
}
defer task.Delete(ctx)
statusC := make(chan uint32, 1)
go func() {
status, err := task.Wait(ctx)
if err != nil {
t.Error(err)
}
statusC <- status
}()
// check that the task has a limit of 32mb
cgroup, err := cgroups.Load(cgroups.V1, cgroups.PidPath(int(task.Pid())))
if err != nil {
t.Error(err)
return
}
stat, err := cgroup.Stat(cgroups.IgnoreNotExist)
if err != nil {
t.Error(err)
return
}
if stat.Memory.Usage.Limit != limit {
t.Errorf("expected memory limit to be set to %d but received %d", limit, stat.Memory.Usage.Limit)
return
}
limit = 64 * 1024 * 1024
if err := task.Update(ctx, WithResources(&specs.LinuxResources{
Memory: &specs.LinuxMemory{
Limit: &limit,
},
})); err != nil {
t.Error(err)
}
// check that the task has a limit of 64mb
if stat, err = cgroup.Stat(cgroups.IgnoreNotExist); err != nil {
t.Error(err)
return
}
if stat.Memory.Usage.Limit != limit {
t.Errorf("expected memory limit to be set to %d but received %d", limit, stat.Memory.Usage.Limit)
}
if err := task.Kill(ctx, syscall.SIGKILL); err != nil {
t.Error(err)
return
}
<-statusC
}

9
linux/shim/init.go
View File

@ -23,6 +23,7 @@ import (
"github.com/containerd/containerd/plugin"
"github.com/containerd/fifo"
runc "github.com/containerd/go-runc"
specs "github.com/opencontainers/runtime-spec/specs-go"
"github.com/pkg/errors"
)
@ -284,6 +285,14 @@ func (p *initProcess) Checkpoint(context context.Context, r *shimapi.CheckpointT
return nil
}
func (p *initProcess) Update(context context.Context, r *shimapi.UpdateTaskRequest) error {
var resources specs.LinuxResources
if err := json.Unmarshal(r.Resources.Value, &resources); err != nil {
return err
}
return p.runc.Update(context, p.id, &resources)
}
// TODO(mlaventure): move to runc package?
func getLastRuncError(r *runc.Runc) (string, error) {
if r.Log == "" {

4
linux/shim/local.go
View File

@ -91,6 +91,10 @@ func (c *local) ShimInfo(ctx context.Context, in *google_protobuf.Empty, opts ..
return c.s.ShimInfo(ctx, in)
}
func (c *local) Update(ctx context.Context, in *shimapi.UpdateTaskRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
return c.s.Update(ctx, in)
}
type events struct {
c chan *shimapi.Event
ctx context.Context

10
linux/shim/service.go
View File

@ -364,6 +364,16 @@ func (s *Service) ShimInfo(ctx context.Context, r *google_protobuf.Empty) (*shim
}, nil
}
func (s *Service) Update(ctx context.Context, r *shimapi.UpdateTaskRequest) (*google_protobuf.Empty, error) {
if s.initProcess == nil {
return nil, errors.New(ErrContainerNotCreated)
}
if err := s.initProcess.Update(ctx, r); err != nil {
return nil, err
}
return empty, nil
}
func (s *Service) waitExit(p process, pid int, cmd *reaper.Cmd) {
status := <-cmd.ExitCh
p.Exited(status)

328
linux/shim/v1/shim.pb.go
View File

@ -25,6 +25,7 @@
ShimInfoResponse
StreamEventsRequest
Event
UpdateTaskRequest
*/
package shim
@ -258,6 +259,14 @@ func (m *Event) Reset() { *m = Event{} }
func (*Event) ProtoMessage() {}
func (*Event) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{15} }
type UpdateTaskRequest struct {
Resources *google_protobuf.Any `protobuf:"bytes,1,opt,name=resources" json:"resources,omitempty"`
}
func (m *UpdateTaskRequest) Reset() { *m = UpdateTaskRequest{} }
func (*UpdateTaskRequest) ProtoMessage() {}
func (*UpdateTaskRequest) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{16} }
func init() {
proto.RegisterType((*CreateTaskRequest)(nil), "containerd.runtime.linux.shim.v1.CreateTaskRequest")
proto.RegisterType((*CreateTaskResponse)(nil), "containerd.runtime.linux.shim.v1.CreateTaskResponse")
@ -275,6 +284,7 @@ func init() {
proto.RegisterType((*ShimInfoResponse)(nil), "containerd.runtime.linux.shim.v1.ShimInfoResponse")
proto.RegisterType((*StreamEventsRequest)(nil), "containerd.runtime.linux.shim.v1.StreamEventsRequest")
proto.RegisterType((*Event)(nil), "containerd.runtime.linux.shim.v1.Event")
proto.RegisterType((*UpdateTaskRequest)(nil), "containerd.runtime.linux.shim.v1.UpdateTaskRequest")
proto.RegisterEnum("containerd.runtime.linux.shim.v1.Event_EventType", Event_EventType_name, Event_EventType_value)
}
@ -306,6 +316,7 @@ type ShimClient interface {
CloseIO(ctx context.Context, in *CloseIORequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error)
// ShimInfo returns information about the shim.
ShimInfo(ctx context.Context, in *google_protobuf1.Empty, opts ...grpc.CallOption) (*ShimInfoResponse, error)
Update(ctx context.Context, in *UpdateTaskRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error)
}
type shimClient struct {
@ -474,6 +485,15 @@ func (c *shimClient) ShimInfo(ctx context.Context, in *google_protobuf1.Empty, o
return out, nil
}
func (c *shimClient) Update(ctx context.Context, in *UpdateTaskRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) {
out := new(google_protobuf1.Empty)
err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/Update", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for Shim service
type ShimServer interface {
@ -494,6 +514,7 @@ type ShimServer interface {
CloseIO(context.Context, *CloseIORequest) (*google_protobuf1.Empty, error)
// ShimInfo returns information about the shim.
ShimInfo(context.Context, *google_protobuf1.Empty) (*ShimInfoResponse, error)
Update(context.Context, *UpdateTaskRequest) (*google_protobuf1.Empty, error)
}
func RegisterShimServer(s *grpc.Server, srv ShimServer) {
@ -773,6 +794,24 @@ func _Shim_ShimInfo_Handler(srv interface{}, ctx context.Context, dec func(inter
return interceptor(ctx, in, info, handler)
}
func _Shim_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(UpdateTaskRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ShimServer).Update(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.runtime.linux.shim.v1.Shim/Update",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ShimServer).Update(ctx, req.(*UpdateTaskRequest))
}
return interceptor(ctx, in, info, handler)
}
var _Shim_serviceDesc = grpc.ServiceDesc{
ServiceName: "containerd.runtime.linux.shim.v1.Shim",
HandlerType: (*ShimServer)(nil),
@ -833,6 +872,10 @@ var _Shim_serviceDesc = grpc.ServiceDesc{
MethodName: "ShimInfo",
Handler: _Shim_ShimInfo_Handler,
},
{
MethodName: "Update",
Handler: _Shim_Update_Handler,
},
},
Streams: []grpc.StreamDesc{
{
@ -1460,6 +1503,34 @@ func (m *Event) MarshalTo(dAtA []byte) (int, error) {
return i, nil
}
func (m *UpdateTaskRequest) 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 *UpdateTaskRequest) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Resources != nil {
dAtA[i] = 0xa
i++
i = encodeVarintShim(dAtA, i, uint64(m.Resources.Size()))
n4, err := m.Resources.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n4
}
return i, nil
}
func encodeFixed64Shim(dAtA []byte, offset int, v uint64) int {
dAtA[offset] = uint8(v)
dAtA[offset+1] = uint8(v >> 8)
@ -1759,6 +1830,16 @@ func (m *Event) Size() (n int) {
return n
}
func (m *UpdateTaskRequest) Size() (n int) {
var l int
_ = l
if m.Resources != nil {
l = m.Resources.Size()
n += 1 + l + sovShim(uint64(l))
}
return n
}
func sovShim(x uint64) (n int) {
for {
n++
@ -1974,6 +2055,16 @@ func (this *Event) String() string {
}, "")
return s
}
func (this *UpdateTaskRequest) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&UpdateTaskRequest{`,
`Resources:` + strings.Replace(fmt.Sprintf("%v", this.Resources), "Any", "google_protobuf.Any", 1) + `,`,
`}`,
}, "")
return s
}
func valueToStringShim(v interface{}) string {
rv := reflect.ValueOf(v)
if rv.IsNil() {
@ -4058,6 +4149,89 @@ func (m *Event) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *UpdateTaskRequest) 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 ErrIntOverflowShim
}
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: UpdateTaskRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: UpdateTaskRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowShim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthShim
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Resources == nil {
m.Resources = &google_protobuf.Any{}
}
if err := m.Resources.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipShim(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthShim
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipShim(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0
@ -4168,80 +4342,82 @@ func init() {
}
var fileDescriptorShim = []byte{
// 1186 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xcf, 0x73, 0xdb, 0xc4,
0x17, 0x8f, 0xfc, 0x43, 0xb6, 0x5f, 0xbe, 0xce, 0xb8, 0xdb, 0x34, 0x5f, 0xd5, 0x65, 0x9c, 0x8c,
0x0e, 0x34, 0x33, 0x4c, 0xe5, 0xc6, 0xa1, 0x4d, 0x08, 0x27, 0x27, 0xd6, 0x21, 0x03, 0x99, 0x98,
0xb5, 0x81, 0x0e, 0x33, 0x90, 0x51, 0xec, 0x8d, 0x2d, 0x22, 0x4b, 0x42, 0xbb, 0x0a, 0x31, 0xa7,
0x9e, 0x38, 0xf3, 0x27, 0x70, 0xe0, 0xce, 0x5f, 0xc0, 0x99, 0x1c, 0x39, 0x72, 0x2a, 0x6d, 0xfe,
0x12, 0x66, 0x57, 0x92, 0x2d, 0xdb, 0x51, 0x6d, 0x67, 0xb8, 0x58, 0xfb, 0x76, 0xdf, 0xdb, 0xfd,
0xec, 0xe7, 0xfd, 0x5a, 0xc3, 0x27, 0x3d, 0x93, 0xf5, 0xfd, 0x73, 0xad, 0xe3, 0x0c, 0xaa, 0x1d,
0xc7, 0x66, 0x86, 0x69, 0x13, 0xaf, 0x1b, 0x1f, 0x5a, 0xa6, 0xed, 0x5f, 0x57, 0x69, 0xdf, 0x1c,
0x54, 0xaf, 0x76, 0xc4, 0x57, 0x73, 0x3d, 0x87, 0x39, 0x68, 0x6b, 0xac, 0xa4, 0x79, 0xbe, 0xcd,
0xcc, 0x01, 0xd1, 0x84, 0xb2, 0x26, 0x94, 0xae, 0x76, 0xca, 0x8f, 0x7b, 0x8e, 0xd3, 0xb3, 0x48,
0x55, 0xe8, 0x9f, 0xfb, 0x17, 0x55, 0xc3, 0x1e, 0x06, 0xc6, 0xe5, 0x27, 0xd3, 0x4b, 0x64, 0xe0,
0xb2, 0x68, 0x71, 0xbd, 0xe7, 0xf4, 0x1c, 0x31, 0xac, 0xf2, 0x51, 0x38, 0xbb, 0x39, 0x6d, 0xc2,
0x4f, 0xa4, 0xcc, 0x18, 0xb8, 0xa1, 0xc2, 0xcb, 0xb9, 0x77, 0x31, 0x5c, 0xb3, 0xca, 0x86, 0x2e,
0xa1, 0xd5, 0x81, 0xe3, 0xdb, 0x2c, 0xb4, 0x3b, 0x58, 0xc2, 0x8e, 0x19, 0xf4, 0x52, 0xfc, 0x04,
0xb6, 0xea, 0x1f, 0x29, 0x78, 0x70, 0xe4, 0x11, 0x83, 0x91, 0xb6, 0x41, 0x2f, 0x31, 0xf9, 0xc1,
0x27, 0x94, 0xa1, 0x0d, 0x48, 0x99, 0x5d, 0x45, 0xda, 0x92, 0xb6, 0x0b, 0x87, 0xf2, 0xed, 0x9b,
0xcd, 0xd4, 0x71, 0x03, 0xa7, 0xcc, 0x2e, 0xda, 0x00, 0xf9, 0xdc, 0xb7, 0xbb, 0x16, 0x51, 0x52,
0x7c, 0x0d, 0x87, 0x12, 0x52, 0x20, 0x17, 0x32, 0xa8, 0xa4, 0xc5, 0x42, 0x24, 0xa2, 0x2a, 0xc8,
0x9e, 0xe3, 0xb0, 0x0b, 0xaa, 0x64, 0xb6, 0xd2, 0xdb, 0xab, 0xb5, 0xff, 0x6b, 0x31, 0xd6, 0x05,
0x24, 0xed, 0x84, 0x5f, 0x05, 0x87, 0x6a, 0xa8, 0x0c, 0x79, 0x46, 0xbc, 0x81, 0x69, 0x1b, 0x96,
0x92, 0xdd, 0x92, 0xb6, 0xf3, 0x78, 0x24, 0xa3, 0x75, 0xc8, 0x52, 0xd6, 0x35, 0x6d, 0x45, 0x16,
0x87, 0x04, 0x02, 0x07, 0x45, 0x59, 0xd7, 0xf1, 0x99, 0x92, 0x0b, 0x40, 0x05, 0x52, 0x38, 0x4f,
0x3c, 0x4f, 0xc9, 0x8f, 0xe6, 0x89, 0xe7, 0xa1, 0x0a, 0x40, 0xa7, 0x4f, 0x3a, 0x97, 0xae, 0x63,
0xda, 0x4c, 0x29, 0x88, 0xb5, 0xd8, 0x0c, 0xfa, 0x08, 0x1e, 0xb8, 0x86, 0x47, 0x6c, 0x76, 0x16,
0x53, 0x03, 0xa1, 0x56, 0x0a, 0x16, 0x8e, 0x46, 0xf3, 0xea, 0x87, 0x80, 0xe2, 0xf4, 0x51, 0xd7,
0xb1, 0x29, 0x41, 0x25, 0x48, 0xbb, 0x21, 0x81, 0x45, 0xcc, 0x87, 0xea, 0xcf, 0x12, 0xac, 0x35,
0x88, 0x45, 0x18, 0x49, 0x56, 0x42, 0x9b, 0xb0, 0x4a, 0xae, 0x4d, 0x76, 0x46, 0x99, 0xc1, 0x7c,
0x2a, 0x38, 0x2e, 0x62, 0xe0, 0x53, 0x2d, 0x31, 0x83, 0xea, 0x50, 0xe0, 0x12, 0xe9, 0x9e, 0x19,
0x4c, 0x30, 0xbd, 0x5a, 0x2b, 0x6b, 0x41, 0x58, 0x69, 0x51, 0x58, 0x69, 0xed, 0x28, 0xac, 0x0e,
0xf3, 0x37, 0x6f, 0x36, 0x57, 0x7e, 0xf9, 0x67, 0x53, 0xc2, 0xf9, 0xc0, 0xac, 0xce, 0xd4, 0x6d,
0x58, 0x0f, 0x70, 0x34, 0x3d, 0xa7, 0x43, 0x28, 0x8d, 0x5c, 0x3e, 0x0b, 0xf9, 0x57, 0x09, 0x90,
0x7e, 0x4d, 0x3a, 0x53, 0x8a, 0x71, 0x07, 0x49, 0x49, 0x0e, 0x4a, 0xdd, 0xed, 0xa0, 0x74, 0x82,
0x83, 0x32, 0x13, 0x0e, 0xda, 0x86, 0x0c, 0x75, 0x49, 0x47, 0xb8, 0x7f, 0xb5, 0xb6, 0x3e, 0x73,
0xc1, 0xba, 0x3d, 0xc4, 0x42, 0x43, 0x7d, 0x0a, 0x0f, 0x27, 0x10, 0x26, 0xd2, 0x8f, 0xa1, 0x84,
0x09, 0x35, 0x7f, 0x22, 0x4d, 0x36, 0x4c, 0xbc, 0x31, 0x87, 0xff, 0xa3, 0xd9, 0x65, 0xfd, 0x90,
0xf9, 0x40, 0xe0, 0x30, 0xfb, 0xc4, 0xec, 0xf5, 0x03, 0xf8, 0x45, 0x1c, 0x4a, 0xea, 0x6f, 0x29,
0x28, 0x72, 0xbf, 0x8c, 0x3d, 0xba, 0x6c, 0xda, 0x84, 0x08, 0xd2, 0x63, 0x04, 0xbb, 0x9c, 0x12,
0xe1, 0x7c, 0x4e, 0xc9, 0x5a, 0xed, 0x49, 0x3c, 0x5d, 0xae, 0x76, 0xc2, 0x8c, 0x09, 0xa2, 0x01,
0x87, 0xaa, 0xe8, 0x00, 0x0a, 0x6e, 0xc0, 0x00, 0xa1, 0x4a, 0x56, 0xa4, 0xd9, 0x07, 0x77, 0xda,
0x45, 0x3c, 0x8d, 0xd5, 0xff, 0xa3, 0x94, 0x8a, 0xc7, 0x44, 0x61, 0x32, 0x26, 0xd4, 0x63, 0x58,
0xfd, 0xcc, 0xb4, 0xac, 0x71, 0x69, 0x91, 0xa9, 0xd9, 0x8b, 0x82, 0xa7, 0x88, 0x43, 0x89, 0x73,
0x61, 0x58, 0x96, 0x20, 0x28, 0x8f, 0xf9, 0x70, 0x96, 0x1d, 0x75, 0x1f, 0xd6, 0x8e, 0x2c, 0x87,
0x92, 0xe3, 0xd3, 0xf7, 0xfa, 0x70, 0x1c, 0x82, 0xf9, 0xf0, 0x42, 0xaa, 0x06, 0xeb, 0x9f, 0x9b,
0x94, 0x35, 0xa3, 0x7b, 0xcf, 0x29, 0x74, 0x6a, 0x0b, 0x1e, 0x4d, 0xe9, 0x87, 0x2e, 0x9e, 0xe0,
0x5a, 0x5a, 0x8a, 0x6b, 0xf5, 0x4f, 0x09, 0x1e, 0x8d, 0x4b, 0x47, 0xbc, 0xde, 0x22, 0xc8, 0xb8,
0x06, 0xeb, 0x07, 0x40, 0xb0, 0x18, 0xa3, 0xef, 0x20, 0xe7, 0xb8, 0xcc, 0x74, 0x6c, 0x5e, 0x08,
0xf8, 0x39, 0x0d, 0x6d, 0x5e, 0xc3, 0xd2, 0xee, 0xdc, 0x5d, 0x3b, 0x0d, 0xb6, 0xd1, 0x6d, 0xe6,
0x0d, 0x71, 0xb4, 0x69, 0xf9, 0x00, 0xfe, 0x17, 0x5f, 0xe0, 0x54, 0x5e, 0x92, 0x61, 0x08, 0x81,
0x0f, 0x39, 0x95, 0x57, 0x86, 0xe5, 0x47, 0x51, 0x1b, 0x08, 0x07, 0xa9, 0x7d, 0x49, 0x7d, 0x06,
0xa5, 0x56, 0xdf, 0x1c, 0x1c, 0xdb, 0x17, 0xce, 0x88, 0x99, 0xc7, 0x90, 0xe7, 0x30, 0xce, 0xc6,
0xfe, 0xc8, 0x71, 0xb9, 0x69, 0x76, 0xd5, 0x47, 0xf0, 0xb0, 0xc5, 0x3c, 0x62, 0x0c, 0xf4, 0x2b,
0x62, 0xb3, 0x88, 0x7c, 0xf5, 0xf7, 0x14, 0x64, 0xc5, 0x4c, 0x62, 0xe2, 0xe8, 0x90, 0xe1, 0x6c,
0x0a, 0x00, 0x6b, 0xb5, 0x9d, 0xf9, 0x04, 0x88, 0xed, 0x82, 0xdf, 0xf6, 0xd0, 0x25, 0x58, 0x98,
0xdf, 0x91, 0x67, 0x53, 0x95, 0x36, 0xf3, 0xfe, 0x4a, 0x9b, 0xbd, 0x57, 0xa5, 0xfd, 0x02, 0x0a,
0x23, 0x20, 0x28, 0x0f, 0x19, 0xfd, 0xd5, 0x71, 0xbb, 0xb4, 0x82, 0x72, 0x90, 0x3e, 0x3d, 0x3d,
0x29, 0x49, 0x08, 0x40, 0x3e, 0xc2, 0x7a, 0xbd, 0xad, 0x97, 0x52, 0xa8, 0x00, 0xd9, 0x56, 0xbb,
0x8e, 0xdb, 0xa5, 0x34, 0x5a, 0x03, 0xd0, 0x5f, 0xe9, 0x47, 0x67, 0xf5, 0x46, 0x43, 0x6f, 0x94,
0x32, 0x5c, 0xad, 0x59, 0xff, 0xb2, 0xa5, 0x37, 0x4a, 0xd9, 0xda, 0x5b, 0x80, 0x0c, 0x27, 0x1e,
0x35, 0x21, 0x2b, 0x4a, 0x0f, 0xda, 0x98, 0x01, 0xa5, 0xf3, 0x87, 0x48, 0xb9, 0x3a, 0x9f, 0xab,
0xc9, 0xda, 0x45, 0x41, 0x0e, 0x1a, 0x19, 0xda, 0x5d, 0x20, 0xce, 0xa6, 0x5f, 0x0c, 0xe5, 0x8f,
0x97, 0x33, 0x0a, 0x0f, 0xdd, 0x13, 0xd7, 0xf0, 0x58, 0xe2, 0x35, 0x12, 0xe6, 0x11, 0x06, 0x39,
0xe8, 0x62, 0x89, 0x96, 0xcf, 0xe7, 0x03, 0x9a, 0xea, 0xc7, 0x43, 0x28, 0x4e, 0x74, 0x46, 0xf4,
0x72, 0xd1, 0x2d, 0x26, 0x3b, 0xe4, 0x3d, 0x8e, 0x7e, 0x2d, 0x41, 0x71, 0xa2, 0xde, 0x2c, 0x72,
0xf6, 0x5d, 0x05, 0xad, 0xbc, 0xb7, 0xb4, 0xdd, 0xd8, 0x15, 0x4d, 0xc3, 0xa7, 0x64, 0x69, 0x57,
0xec, 0x83, 0x8c, 0x09, 0xf5, 0x07, 0xcb, 0x5b, 0x7e, 0x0b, 0x30, 0x2e, 0x58, 0x68, 0xef, 0x9e,
0xe5, 0x2d, 0x71, 0xfb, 0xef, 0x41, 0x0e, 0xaa, 0x0e, 0x7a, 0xb1, 0x48, 0x32, 0xcc, 0xd4, 0xa7,
0xf2, 0xd3, 0x05, 0xeb, 0xcd, 0x73, 0x09, 0x9d, 0x40, 0x86, 0x37, 0x39, 0xf4, 0x6c, 0xbe, 0x49,
0xac, 0x19, 0x26, 0x42, 0xa7, 0x90, 0xe1, 0xef, 0x1a, 0xb4, 0x40, 0x56, 0xcd, 0xbe, 0xd0, 0xca,
0x2f, 0x96, 0xb4, 0x0a, 0x23, 0xe0, 0x6b, 0x28, 0x8c, 0xde, 0x48, 0xa8, 0x36, 0x7f, 0x8f, 0xe9,
0x07, 0x55, 0xe2, 0x6d, 0x5a, 0x90, 0x0b, 0xdb, 0x36, 0x5a, 0x20, 0x35, 0x26, 0x3b, 0x7c, 0xe2,
0xa6, 0x5f, 0x41, 0x3e, 0x6a, 0x41, 0x89, 0x81, 0xb7, 0xc0, 0x25, 0xa6, 0xdb, 0xd8, 0xe1, 0xc9,
0xcd, 0xbb, 0xca, 0xca, 0xdf, 0xef, 0x2a, 0x2b, 0xaf, 0x6f, 0x2b, 0xd2, 0xcd, 0x6d, 0x45, 0xfa,
0xeb, 0xb6, 0x22, 0xbd, 0xbd, 0xad, 0x48, 0xdf, 0xec, 0x2e, 0xf7, 0x57, 0xf3, 0x53, 0xfe, 0x3d,
0x97, 0x05, 0xa4, 0xdd, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x26, 0xd4, 0xa9, 0x94, 0xa8, 0x0e,
0x00, 0x00,
// 1224 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xcf, 0x6f, 0xe3, 0xc4,
0x17, 0xaf, 0xf3, 0xc3, 0x49, 0x5e, 0xbe, 0xa9, 0xb2, 0xb3, 0xdd, 0x7e, 0xb3, 0x59, 0x94, 0x56,
0x3e, 0xb0, 0x95, 0xd0, 0x3a, 0xdb, 0x94, 0xdd, 0x96, 0x72, 0x4a, 0x1b, 0x0b, 0x55, 0x50, 0x35,
0x4c, 0x52, 0x58, 0x21, 0x41, 0xe5, 0x26, 0xd3, 0xc4, 0x34, 0xb1, 0x8d, 0x67, 0x5c, 0x1a, 0x4e,
0x7b, 0xe2, 0xcc, 0x9f, 0xc0, 0x81, 0x3b, 0x47, 0x4e, 0x9c, 0xe9, 0x91, 0x23, 0xa7, 0x85, 0xed,
0x5f, 0x82, 0x66, 0x6c, 0xc7, 0x4e, 0x52, 0x6f, 0x92, 0x8a, 0x4b, 0x3c, 0x6f, 0xe6, 0xbd, 0x99,
0x37, 0x9f, 0xf7, 0xde, 0xe7, 0x4d, 0xe0, 0xa3, 0x9e, 0xc1, 0xfa, 0xee, 0xb9, 0xda, 0xb1, 0x86,
0xd5, 0x8e, 0x65, 0x32, 0xdd, 0x30, 0x89, 0xd3, 0x8d, 0x0e, 0x07, 0x86, 0xe9, 0x5e, 0x57, 0x69,
0xdf, 0x18, 0x56, 0xaf, 0xb6, 0xc5, 0x57, 0xb5, 0x1d, 0x8b, 0x59, 0x68, 0x33, 0x54, 0x52, 0x1d,
0xd7, 0x64, 0xc6, 0x90, 0xa8, 0x42, 0x59, 0x15, 0x4a, 0x57, 0xdb, 0xe5, 0xc7, 0x3d, 0xcb, 0xea,
0x0d, 0x48, 0x55, 0xe8, 0x9f, 0xbb, 0x17, 0x55, 0xdd, 0x1c, 0x79, 0xc6, 0xe5, 0x27, 0xd3, 0x4b,
0x64, 0x68, 0xb3, 0x60, 0x71, 0xad, 0x67, 0xf5, 0x2c, 0x31, 0xac, 0xf2, 0x91, 0x3f, 0xbb, 0x31,
0x6d, 0xc2, 0x4f, 0xa4, 0x4c, 0x1f, 0xda, 0xbe, 0xc2, 0xcb, 0xb9, 0x77, 0xd1, 0x6d, 0xa3, 0xca,
0x46, 0x36, 0xa1, 0xd5, 0xa1, 0xe5, 0x9a, 0xcc, 0xb7, 0xdb, 0x5f, 0xc2, 0x8e, 0xe9, 0xf4, 0x52,
0xfc, 0x78, 0xb6, 0xca, 0xef, 0x09, 0x78, 0x70, 0xe8, 0x10, 0x9d, 0x91, 0xb6, 0x4e, 0x2f, 0x31,
0xf9, 0xce, 0x25, 0x94, 0xa1, 0x75, 0x48, 0x18, 0xdd, 0x92, 0xb4, 0x29, 0x6d, 0xe5, 0x0e, 0xe4,
0xdb, 0x37, 0x1b, 0x89, 0xa3, 0x06, 0x4e, 0x18, 0x5d, 0xb4, 0x0e, 0xf2, 0xb9, 0x6b, 0x76, 0x07,
0xa4, 0x94, 0xe0, 0x6b, 0xd8, 0x97, 0x50, 0x09, 0x32, 0x3e, 0x82, 0xa5, 0xa4, 0x58, 0x08, 0x44,
0x54, 0x05, 0xd9, 0xb1, 0x2c, 0x76, 0x41, 0x4b, 0xa9, 0xcd, 0xe4, 0x56, 0xbe, 0xf6, 0x7f, 0x35,
0x82, 0xba, 0x70, 0x49, 0x3d, 0xe6, 0x57, 0xc1, 0xbe, 0x1a, 0x2a, 0x43, 0x96, 0x11, 0x67, 0x68,
0x98, 0xfa, 0xa0, 0x94, 0xde, 0x94, 0xb6, 0xb2, 0x78, 0x2c, 0xa3, 0x35, 0x48, 0x53, 0xd6, 0x35,
0xcc, 0x92, 0x2c, 0x0e, 0xf1, 0x04, 0xee, 0x14, 0x65, 0x5d, 0xcb, 0x65, 0xa5, 0x8c, 0xe7, 0x94,
0x27, 0xf9, 0xf3, 0xc4, 0x71, 0x4a, 0xd9, 0xf1, 0x3c, 0x71, 0x1c, 0x54, 0x01, 0xe8, 0xf4, 0x49,
0xe7, 0xd2, 0xb6, 0x0c, 0x93, 0x95, 0x72, 0x62, 0x2d, 0x32, 0x83, 0x3e, 0x80, 0x07, 0xb6, 0xee,
0x10, 0x93, 0x9d, 0x45, 0xd4, 0x40, 0xa8, 0x15, 0xbd, 0x85, 0xc3, 0xf1, 0xbc, 0xf2, 0x3e, 0xa0,
0x28, 0x7c, 0xd4, 0xb6, 0x4c, 0x4a, 0x50, 0x11, 0x92, 0xb6, 0x0f, 0x60, 0x01, 0xf3, 0xa1, 0xf2,
0xa3, 0x04, 0xab, 0x0d, 0x32, 0x20, 0x8c, 0xc4, 0x2b, 0xa1, 0x0d, 0xc8, 0x93, 0x6b, 0x83, 0x9d,
0x51, 0xa6, 0x33, 0x97, 0x0a, 0x8c, 0x0b, 0x18, 0xf8, 0x54, 0x4b, 0xcc, 0xa0, 0x3a, 0xe4, 0xb8,
0x44, 0xba, 0x67, 0x3a, 0x13, 0x48, 0xe7, 0x6b, 0x65, 0xd5, 0x4b, 0x2b, 0x35, 0x48, 0x2b, 0xb5,
0x1d, 0xa4, 0xd5, 0x41, 0xf6, 0xe6, 0xcd, 0xc6, 0xca, 0x4f, 0x7f, 0x6f, 0x48, 0x38, 0xeb, 0x99,
0xd5, 0x99, 0xb2, 0x05, 0x6b, 0x9e, 0x1f, 0x4d, 0xc7, 0xea, 0x10, 0x4a, 0x83, 0x90, 0xcf, 0xba,
0xfc, 0xb3, 0x04, 0x48, 0xbb, 0x26, 0x9d, 0x29, 0xc5, 0x68, 0x80, 0xa4, 0xb8, 0x00, 0x25, 0xee,
0x0e, 0x50, 0x32, 0x26, 0x40, 0xa9, 0x89, 0x00, 0x6d, 0x41, 0x8a, 0xda, 0xa4, 0x23, 0xc2, 0x9f,
0xaf, 0xad, 0xcd, 0x5c, 0xb0, 0x6e, 0x8e, 0xb0, 0xd0, 0x50, 0x9e, 0xc2, 0xc3, 0x09, 0x0f, 0x63,
0xe1, 0xc7, 0x50, 0xc4, 0x84, 0x1a, 0x3f, 0x90, 0x26, 0x1b, 0xc5, 0xde, 0x98, 0xbb, 0xff, 0xbd,
0xd1, 0x65, 0x7d, 0x1f, 0x79, 0x4f, 0xe0, 0x6e, 0xf6, 0x89, 0xd1, 0xeb, 0x7b, 0xee, 0x17, 0xb0,
0x2f, 0x29, 0xbf, 0x24, 0xa0, 0xc0, 0xe3, 0x12, 0x46, 0x74, 0xd9, 0xb2, 0xf1, 0x3d, 0x48, 0x86,
0x1e, 0xec, 0x70, 0x48, 0x44, 0xf0, 0x39, 0x24, 0xab, 0xb5, 0x27, 0xd1, 0x72, 0xb9, 0xda, 0xf6,
0x2b, 0xc6, 0xcb, 0x06, 0xec, 0xab, 0xa2, 0x7d, 0xc8, 0xd9, 0x1e, 0x02, 0x84, 0x96, 0xd2, 0xa2,
0xcc, 0xde, 0xbb, 0xd3, 0x2e, 0xc0, 0x29, 0x54, 0xff, 0x8f, 0x4a, 0x2a, 0x9a, 0x13, 0xb9, 0xc9,
0x9c, 0x50, 0x8e, 0x20, 0xff, 0xa9, 0x31, 0x18, 0x84, 0xd4, 0x22, 0x53, 0xa3, 0x17, 0x24, 0x4f,
0x01, 0xfb, 0x12, 0xc7, 0x42, 0x1f, 0x0c, 0x04, 0x40, 0x59, 0xcc, 0x87, 0xb3, 0xe8, 0x28, 0x7b,
0xb0, 0x7a, 0x38, 0xb0, 0x28, 0x39, 0x3a, 0x79, 0x67, 0x0c, 0xc3, 0x14, 0xcc, 0xfa, 0x17, 0x52,
0x54, 0x58, 0xfb, 0xcc, 0xa0, 0xac, 0x19, 0xdc, 0x7b, 0x0e, 0xd1, 0x29, 0x2d, 0x78, 0x34, 0xa5,
0xef, 0x87, 0x78, 0x02, 0x6b, 0x69, 0x29, 0xac, 0x95, 0x3f, 0x24, 0x78, 0x14, 0x52, 0x47, 0x94,
0x6f, 0x11, 0xa4, 0x6c, 0x9d, 0xf5, 0x3d, 0x47, 0xb0, 0x18, 0xa3, 0x6f, 0x20, 0x63, 0xd9, 0xcc,
0xb0, 0x4c, 0x4e, 0x04, 0xfc, 0x9c, 0x86, 0x3a, 0xaf, 0x61, 0xa9, 0x77, 0xee, 0xae, 0x9e, 0x78,
0xdb, 0x68, 0x26, 0x73, 0x46, 0x38, 0xd8, 0xb4, 0xbc, 0x0f, 0xff, 0x8b, 0x2e, 0x70, 0x28, 0x2f,
0xc9, 0xc8, 0x77, 0x81, 0x0f, 0x39, 0x94, 0x57, 0xfa, 0xc0, 0x0d, 0xb2, 0xd6, 0x13, 0xf6, 0x13,
0x7b, 0x92, 0xf2, 0x0c, 0x8a, 0xad, 0xbe, 0x31, 0x3c, 0x32, 0x2f, 0xac, 0x31, 0x32, 0x8f, 0x21,
0xcb, 0xdd, 0x38, 0x0b, 0xe3, 0x91, 0xe1, 0x72, 0xd3, 0xe8, 0x2a, 0x8f, 0xe0, 0x61, 0x8b, 0x39,
0x44, 0x1f, 0x6a, 0x57, 0xc4, 0x64, 0x01, 0xf8, 0xca, 0xaf, 0x09, 0x48, 0x8b, 0x99, 0xd8, 0xc2,
0xd1, 0x20, 0xc5, 0xd1, 0x14, 0x0e, 0xac, 0xd6, 0xb6, 0xe7, 0x03, 0x20, 0xb6, 0xf3, 0x7e, 0xdb,
0x23, 0x9b, 0x60, 0x61, 0x7e, 0x47, 0x9d, 0x4d, 0x31, 0x6d, 0xea, 0xdd, 0x4c, 0x9b, 0xbe, 0x17,
0xd3, 0x7e, 0x0e, 0xb9, 0xb1, 0x23, 0x28, 0x0b, 0x29, 0xed, 0xd5, 0x51, 0xbb, 0xb8, 0x82, 0x32,
0x90, 0x3c, 0x39, 0x39, 0x2e, 0x4a, 0x08, 0x40, 0x3e, 0xc4, 0x5a, 0xbd, 0xad, 0x15, 0x13, 0x28,
0x07, 0xe9, 0x56, 0xbb, 0x8e, 0xdb, 0xc5, 0x24, 0x5a, 0x05, 0xd0, 0x5e, 0x69, 0x87, 0x67, 0xf5,
0x46, 0x43, 0x6b, 0x14, 0x53, 0x5c, 0xad, 0x59, 0x3f, 0x6d, 0x69, 0x8d, 0x62, 0x5a, 0xf9, 0x04,
0x1e, 0x9c, 0xda, 0xdd, 0xa9, 0x66, 0x5d, 0x83, 0x9c, 0x43, 0xa8, 0xe5, 0x3a, 0x1d, 0x91, 0x92,
0xf1, 0x9c, 0x19, 0xaa, 0xd5, 0x7e, 0xcb, 0x43, 0x8a, 0x47, 0x10, 0x35, 0x21, 0x2d, 0x38, 0x0c,
0xad, 0xcf, 0x98, 0x68, 0xfc, 0x45, 0x53, 0xae, 0xce, 0x07, 0x7d, 0x92, 0x04, 0x29, 0xc8, 0x5e,
0x47, 0x44, 0x3b, 0x0b, 0x24, 0xec, 0xf4, 0xd3, 0xa3, 0xfc, 0xe1, 0x72, 0x46, 0xfe, 0xa1, 0xbb,
0xe2, 0x1a, 0x0e, 0x8b, 0xbd, 0x46, 0xcc, 0x3c, 0xc2, 0x20, 0x7b, 0xed, 0x30, 0xd6, 0xf2, 0xf9,
0x7c, 0x87, 0xa6, 0x1a, 0xfb, 0x08, 0x0a, 0x13, 0x2d, 0x16, 0xbd, 0x5c, 0x74, 0x8b, 0xc9, 0x56,
0x7b, 0x8f, 0xa3, 0x5f, 0x4b, 0x50, 0x98, 0x20, 0xae, 0x45, 0xce, 0xbe, 0x8b, 0x19, 0xcb, 0xbb,
0x4b, 0xdb, 0x85, 0xa1, 0x68, 0xea, 0x2e, 0x25, 0x4b, 0x87, 0x62, 0x0f, 0x64, 0x4c, 0xa8, 0x3b,
0x5c, 0xde, 0xf2, 0x6b, 0x80, 0x90, 0xf9, 0xd0, 0xee, 0x3d, 0x79, 0x32, 0x76, 0xfb, 0x6f, 0x41,
0xf6, 0xe8, 0x0b, 0xbd, 0x58, 0xa4, 0x18, 0x66, 0x88, 0xae, 0xfc, 0x74, 0x41, 0xe2, 0x7a, 0x2e,
0xa1, 0x63, 0x48, 0xf1, 0x6e, 0x89, 0x9e, 0xcd, 0x37, 0x89, 0x74, 0xd5, 0x58, 0xd7, 0x29, 0xa4,
0xf8, 0x03, 0x09, 0x2d, 0x50, 0x55, 0xb3, 0x4f, 0xbd, 0xf2, 0x8b, 0x25, 0xad, 0xfc, 0x0c, 0xf8,
0x12, 0x72, 0xe3, 0xc7, 0x16, 0xaa, 0xcd, 0xdf, 0x63, 0xfa, 0x65, 0x16, 0x7b, 0x9b, 0x16, 0x64,
0xfc, 0xfe, 0x8f, 0x16, 0x28, 0x8d, 0xc9, 0xa7, 0x42, 0xec, 0xa6, 0x5f, 0x40, 0x36, 0xe8, 0x65,
0xb1, 0x89, 0xb7, 0xc0, 0x25, 0x66, 0xfa, 0xe1, 0x29, 0xc8, 0x1e, 0x57, 0x2f, 0xc2, 0x83, 0x33,
0xac, 0x1e, 0xe7, 0xee, 0xc1, 0xf1, 0xcd, 0xdb, 0xca, 0xca, 0x5f, 0x6f, 0x2b, 0x2b, 0xaf, 0x6f,
0x2b, 0xd2, 0xcd, 0x6d, 0x45, 0xfa, 0xf3, 0xb6, 0x22, 0xfd, 0x73, 0x5b, 0x91, 0xbe, 0xda, 0x59,
0xee, 0xaf, 0xf0, 0xc7, 0xfc, 0x7b, 0x2e, 0x8b, 0xed, 0x77, 0xfe, 0x0d, 0x00, 0x00, 0xff, 0xff,
0x94, 0x4d, 0x29, 0x2c, 0x48, 0x0f, 0x00, 0x00,
}

6
linux/shim/v1/shim.proto
View File

@ -47,6 +47,8 @@ service Shim {
// ShimInfo returns information about the shim.
rpc ShimInfo(google.protobuf.Empty) returns (ShimInfoResponse);
rpc Update(UpdateTaskRequest) returns (google.protobuf.Empty);
}
message CreateTaskRequest {
@ -154,3 +156,7 @@ message Event {
uint32 exit_status = 4;
google.protobuf.Timestamp exited_at = 5 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
}
message UpdateTaskRequest {
google.protobuf.Any resources = 1;
}

10
linux/task.go
View File

@ -192,6 +192,16 @@ func (t *Task) DeleteProcess(ctx context.Context, pid uint32) (*plugin.Exit, err
}, nil
}
func (t *Task) Update(ctx context.Context, resources []byte) error {
_, err := t.shim.Update(ctx, &shim.UpdateTaskRequest{
Resources: &protobuf.Any{
TypeUrl: specs.Version,
Value: resources,
},
})
return err
}
type Process struct {
pid int
t *Task

2
plugin/task.go
View File

@ -35,6 +35,8 @@ type Task interface {
Checkpoint(context.Context, string, map[string]string) error
// DeleteProcess deletes a specific exec process via the pid
DeleteProcess(context.Context, uint32) (*Exit, error)
// Update sets the provided resources to a running task
Update(context.Context, []byte) error
}
type ExecOpts struct {

11
services/tasks/service.go
View File

@ -451,6 +451,17 @@ func (s *Service) Checkpoint(ctx context.Context, r *api.CheckpointTaskRequest)
}, nil
}
func (s *Service) Update(ctx context.Context, r *api.UpdateTaskRequest) (*google_protobuf.Empty, error) {
t, err := s.getTask(ctx, r.ContainerID)
if err != nil {
return nil, err
}
if err := t.Update(ctx, r.Resources.Value); err != nil {
return nil, err
}
return empty, nil
}
func (s *Service) writeContent(ctx context.Context, mediaType, ref string, r io.Reader) (*types.Descriptor, error) {
writer, err := s.store.Writer(ctx, ref, 0, "")
if err != nil {

15
spec_unix.go
View File

@ -11,6 +11,7 @@ import (
"strings"
"github.com/containerd/containerd/api/services/containers/v1"
"github.com/containerd/containerd/api/services/tasks/v1"
"github.com/containerd/containerd/images"
protobuf "github.com/gogo/protobuf/types"
"github.com/opencontainers/image-spec/specs-go/v1"
@ -290,3 +291,17 @@ func WithSpec(spec *specs.Spec) NewContainerOpts {
return nil
}
}
func WithResources(resources *specs.LinuxResources) UpdateTaskOpts {
return func(ctx context.Context, client *Client, r *tasks.UpdateTaskRequest) error {
data, err := json.Marshal(resources)
if err != nil {
return err
}
r.Resources = &protobuf.Any{
TypeUrl: specs.Version,
Value: data,
}
return nil
}
}

15
spec_windows.go
View File

@ -7,6 +7,7 @@ import (
"runtime"
"github.com/containerd/containerd/api/services/containers/v1"
tasks "github.com/containerd/containerd/api/services/tasks/v1"
"github.com/containerd/containerd/images"
protobuf "github.com/gogo/protobuf/types"
"github.com/opencontainers/image-spec/specs-go/v1"
@ -92,3 +93,17 @@ func WithSpec(spec *specs.Spec) NewContainerOpts {
return nil
}
}
func WithResources(resources *specs.WindowsResources) UpdateTaskOpts {
return func(ctx context.Context, client *Client, r *tasks.UpdateTaskRequest) error {
data, err := json.Marshal(resources)
if err != nil {
return err
}
r.Resources = &protobuf.Any{
TypeUrl: specs.Version,
Value: data,
}
return nil
}
}

16
task.go
View File

@ -57,6 +57,7 @@ type Task interface {
Resize(ctx context.Context, w, h uint32) error
IO() *IO
Checkpoint(context.Context, ...CheckpointOpts) (v1.Descriptor, error)
Update(context.Context, ...UpdateTaskOpts) error
}
type Process interface {
@ -292,6 +293,21 @@ func (t *task) Checkpoint(ctx context.Context, opts ...CheckpointOpts) (d v1.Des
return t.writeIndex(ctx, &index)
}
type UpdateTaskOpts func(context.Context, *Client, *tasks.UpdateTaskRequest) error
func (t *task) Update(ctx context.Context, opts ...UpdateTaskOpts) error {
request := &tasks.UpdateTaskRequest{
ContainerID: t.containerID,
}
for _, o := range opts {
if err := o(ctx, t.client, request); err != nil {
return err
}
}
_, err := t.client.TaskService().Update(ctx, request)
return err
}
func (t *task) checkpointTask(ctx context.Context, index *v1.Index, request *tasks.CheckpointTaskRequest) error {
response, err := t.client.TaskService().Checkpoint(ctx, request)
if err != nil {

4
windows/container.go
View File

@ -214,6 +214,10 @@ func (c *container) DeleteProcess(ctx context.Context, pid uint32) (*plugin.Exit
}, nil
}
func (c *container) Update(ctx context.Context, spec []byte) error {
return fmt.Errorf("Windows containers do not support update")
}
func (c *container) setStatus(status plugin.Status) {
c.Lock()
c.status = status