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

Implement options for runtime specific settings

Browse Source 
Signed-off-by: Michael Crosby <crosbymichael@gmail.com>
This commit is contained in:
Michael Crosby 2017-06-23 14:55:10 -07:00
parent eedcbc64cc
commit 82d0208aaa
18 changed files with 1701 additions and 467 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -57,7 +57,6 @@ 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"
@ -92,6 +91,7 @@ type CreateTaskRequest struct {
Stderr string `protobuf:"bytes,6,opt,name=stderr,proto3" json:"stderr,omitempty"`
Terminal bool `protobuf:"varint,7,opt,name=terminal,proto3" json:"terminal,omitempty"`
Checkpoint *containerd_types1.Descriptor `protobuf:"bytes,8,opt,name=checkpoint" json:"checkpoint,omitempty"`
Options *google_protobuf1.Any `protobuf:"bytes,9,opt,name=options" json:"options,omitempty"`
}
func (m *CreateTaskRequest) Reset() { *m = CreateTaskRequest{} }
@ -374,7 +374,7 @@ func (*ListPidsResponse) Descriptor() ([]byte, []int) { return fileDescriptorTas
type CheckpointTaskRequest struct {
ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
ParentCheckpoint github_com_opencontainers_go_digest.Digest `protobuf:"bytes,2,opt,name=parent_checkpoint,json=parentCheckpoint,proto3,customtype=github.com/opencontainers/go-digest.Digest" json:"parent_checkpoint"`
Options map[string]string `protobuf:"bytes,3,rep,name=options" json:"options,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
Options *google_protobuf1.Any `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
}
func (m *CheckpointTaskRequest) Reset() { *m = CheckpointTaskRequest{} }
@ -1036,6 +1036,16 @@ func (m *CreateTaskRequest) MarshalTo(dAtA []byte) (int, error) {
}
i += n1
}
if m.Options != nil {
dAtA[i] = 0x4a
i++
i = encodeVarintTasks(dAtA, i, uint64(m.Options.Size()))
n2, err := m.Options.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n2
}
return i, nil
}
@ -1150,11 +1160,11 @@ func (m *DeleteResponse) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x22
i++
i = encodeVarintTasks(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.ExitedAt)))
n2, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ExitedAt, dAtA[i:])
n3, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ExitedAt, dAtA[i:])
if err != nil {
return 0, err
}
i += n2
i += n3
return i, nil
}
@ -1230,11 +1240,11 @@ func (m *GetTaskResponse) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0xa
i++
i = encodeVarintTasks(dAtA, i, uint64(m.Task.Size()))
n3, err := m.Task.MarshalTo(dAtA[i:])
n4, err := m.Task.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n3
i += n4
}
return i, nil
}
@ -1320,11 +1330,11 @@ func (m *KillRequest) MarshalTo(dAtA []byte) (int, error) {
i = encodeVarintTasks(dAtA, i, uint64(m.Signal))
}
if m.PidOrAll != nil {
nn4, err := m.PidOrAll.MarshalTo(dAtA[i:])
nn5, err := m.PidOrAll.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += nn4
i += nn5
}
return i, nil
}
@ -1401,11 +1411,11 @@ func (m *ExecProcessRequest) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x32
i++
i = encodeVarintTasks(dAtA, i, uint64(m.Spec.Size()))
n5, err := m.Spec.MarshalTo(dAtA[i:])
n6, err := m.Spec.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n5
i += n6
}
return i, nil
}
@ -1599,21 +1609,21 @@ func (m *ListPidsResponse) MarshalTo(dAtA []byte) (int, error) {
var l int
_ = l
if len(m.Pids) > 0 {
dAtA7 := make([]byte, len(m.Pids)*10)
var j6 int
dAtA8 := make([]byte, len(m.Pids)*10)
var j7 int
for _, num := range m.Pids {
for num >= 1<<7 {
dAtA7[j6] = uint8(uint64(num)&0x7f | 0x80)
dAtA8[j7] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j6++
j7++
}
dAtA7[j6] = uint8(num)
j6++
dAtA8[j7] = uint8(num)
j7++
}
dAtA[i] = 0xa
i++
i = encodeVarintTasks(dAtA, i, uint64(j6))
i += copy(dAtA[i:], dAtA7[:j6])
i = encodeVarintTasks(dAtA, i, uint64(j7))
i += copy(dAtA[i:], dAtA8[:j7])
}
return i, nil
}
@ -1645,22 +1655,15 @@ func (m *CheckpointTaskRequest) MarshalTo(dAtA []byte) (int, error) {
i = encodeVarintTasks(dAtA, i, uint64(len(m.ParentCheckpoint)))
i += copy(dAtA[i:], m.ParentCheckpoint)
}
if len(m.Options) > 0 {
for k, _ := range m.Options {
if m.Options != nil {
dAtA[i] = 0x1a
i++
v := m.Options[k]
mapSize := 1 + len(k) + sovTasks(uint64(len(k))) + 1 + len(v) + sovTasks(uint64(len(v)))
i = encodeVarintTasks(dAtA, i, uint64(mapSize))
dAtA[i] = 0xa
i++
i = encodeVarintTasks(dAtA, i, uint64(len(k)))
i += copy(dAtA[i:], k)
dAtA[i] = 0x12
i++
i = encodeVarintTasks(dAtA, i, uint64(len(v)))
i += copy(dAtA[i:], v)
i = encodeVarintTasks(dAtA, i, uint64(m.Options.Size()))
n9, err := m.Options.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n9
}
return i, nil
}
@ -1720,11 +1723,11 @@ func (m *UpdateTaskRequest) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x12
i++
i = encodeVarintTasks(dAtA, i, uint64(m.Resources.Size()))
n8, err := m.Resources.MarshalTo(dAtA[i:])
n10, err := m.Resources.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n8
i += n10
}
return i, nil
}
@ -1788,6 +1791,10 @@ func (m *CreateTaskRequest) Size() (n int) {
l = m.Checkpoint.Size()
n += 1 + l + sovTasks(uint64(l))
}
if m.Options != nil {
l = m.Options.Size()
n += 1 + l + sovTasks(uint64(l))
}
return n
}
@ -2052,13 +2059,9 @@ func (m *CheckpointTaskRequest) Size() (n int) {
if l > 0 {
n += 1 + l + sovTasks(uint64(l))
}
if len(m.Options) > 0 {
for k, v := range m.Options {
_ = k
_ = v
mapEntrySize := 1 + len(k) + sovTasks(uint64(len(k))) + 1 + len(v) + sovTasks(uint64(len(v)))
n += mapEntrySize + 1 + sovTasks(uint64(mapEntrySize))
}
if m.Options != nil {
l = m.Options.Size()
n += 1 + l + sovTasks(uint64(l))
}
return n
}
@ -2114,6 +2117,7 @@ func (this *CreateTaskRequest) String() string {
`Stderr:` + fmt.Sprintf("%v", this.Stderr) + `,`,
`Terminal:` + fmt.Sprintf("%v", this.Terminal) + `,`,
`Checkpoint:` + strings.Replace(fmt.Sprintf("%v", this.Checkpoint), "Descriptor", "containerd_types1.Descriptor", 1) + `,`,
`Options:` + strings.Replace(fmt.Sprintf("%v", this.Options), "Any", "google_protobuf1.Any", 1) + `,`,
`}`,
}, "")
return s
@ -2339,20 +2343,10 @@ func (this *CheckpointTaskRequest) 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{`&CheckpointTaskRequest{`,
`ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`,
`ParentCheckpoint:` + fmt.Sprintf("%v", this.ParentCheckpoint) + `,`,
`Options:` + mapStringForOptions + `,`,
`Options:` + strings.Replace(fmt.Sprintf("%v", this.Options), "Any", "google_protobuf1.Any", 1) + `,`,
`}`,
}, "")
return s
@ -2615,6 +2609,39 @@ func (m *CreateTaskRequest) Unmarshal(dAtA []byte) error {
return err
}
iNdEx = postIndex
case 9:
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 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.Options == nil {
m.Options = &google_protobuf1.Any{}
}
if err := m.Options.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipTasks(dAtA[iNdEx:])
@ -4602,94 +4629,11 @@ func (m *CheckpointTaskRequest) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
var keykey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTasks
}
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 ErrIntOverflowTasks
}
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 ErrInvalidLengthTasks
}
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)
m.Options = &google_protobuf1.Any{}
}
if iNdEx < postIndex {
var valuekey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTasks
}
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 ErrIntOverflowTasks
}
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 ErrInvalidLengthTasks
}
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
if err := m.Options.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
@ -5016,82 +4960,80 @@ func init() {
}
var fileDescriptorTasks = []byte{
// 1228 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0xcf, 0x6f, 0x1b, 0xc5,
0x17, 0xcf, 0xfa, 0x57, 0x9d, 0xe7, 0xa6, 0x4d, 0xe6, 0x9b, 0x6f, 0x70, 0x97, 0xca, 0x8e, 0xf6,
0x00, 0xa6, 0x22, 0xbb, 0xc4, 0x45, 0x08, 0xb5, 0x15, 0x6a, 0x13, 0x87, 0x12, 0x01, 0x4a, 0xba,
0x29, 0x08, 0x45, 0x48, 0xd6, 0xc6, 0x3b, 0x71, 0x46, 0x5e, 0xef, 0x6e, 0x77, 0xc6, 0x69, 0x0d,
0x17, 0x4e, 0x5c, 0xe1, 0xc8, 0x7f, 0xc0, 0xff, 0xc0, 0x99, 0x43, 0x8e, 0x1c, 0x38, 0x20, 0x0e,
0x81, 0xe6, 0x2f, 0x41, 0xf3, 0xc3, 0x9b, 0x8d, 0x5d, 0x7b, 0x9d, 0x38, 0x97, 0x64, 0xde, 0xec,
0x7b, 0x6f, 0xde, 0xef, 0xcf, 0x93, 0x61, 0xa3, 0x4d, 0xd8, 0x51, 0xef, 0xc0, 0x6c, 0x05, 0x5d,
0xab, 0x15, 0xf8, 0xcc, 0x21, 0x3e, 0x8e, 0xdc, 0xe4, 0xd1, 0x09, 0x89, 0x45, 0x71, 0x74, 0x4c,
0x5a, 0x98, 0x5a, 0xcc, 0xa1, 0x1d, 0x6a, 0x1d, 0xaf, 0xcb, 0x83, 0x19, 0x46, 0x01, 0x0b, 0xd0,
0xdd, 0x73, 0x6e, 0x73, 0xc0, 0x69, 0x4a, 0x86, 0xe3, 0x75, 0xfd, 0xed, 0x76, 0x10, 0xb4, 0x3d,
0x6c, 0x09, 0xde, 0x83, 0xde, 0xa1, 0x85, 0xbb, 0x21, 0xeb, 0x4b, 0x51, 0xfd, 0xce, 0xf0, 0x47,
0xc7, 0x1f, 0x7c, 0x5a, 0x6e, 0x07, 0xed, 0x40, 0x1c, 0x2d, 0x7e, 0x52, 0xb7, 0x1f, 0x4d, 0x65,
0x2f, 0xeb, 0x87, 0x98, 0x5a, 0xdd, 0xa0, 0xe7, 0x33, 0x25, 0xf7, 0xf0, 0x12, 0x72, 0x2e, 0xa6,
0xad, 0x88, 0x84, 0x2c, 0x88, 0x94, 0xf0, 0x83, 0x4b, 0x08, 0x73, 0xbf, 0xc5, 0x1f, 0x25, 0x5b,
0x1d, 0xf6, 0x90, 0x91, 0x2e, 0xa6, 0xcc, 0xe9, 0x86, 0x92, 0xc1, 0xf8, 0x25, 0x03, 0x4b, 0x9b,
0x11, 0x76, 0x18, 0x7e, 0xee, 0xd0, 0x8e, 0x8d, 0x5f, 0xf4, 0x30, 0x65, 0xa8, 0x0e, 0x37, 0x63,
0xf5, 0x4d, 0xe2, 0x96, 0x33, 0xab, 0x5a, 0x6d, 0x7e, 0xe3, 0xf6, 0xd9, 0x69, 0xb5, 0xb4, 0x39,
0xb8, 0xdf, 0x6e, 0xd8, 0xa5, 0x98, 0x69, 0xdb, 0x45, 0x16, 0x14, 0xa2, 0x20, 0x60, 0x87, 0xb4,
0x9c, 0x5d, 0xcd, 0xd6, 0x4a, 0xf5, 0xb7, 0xcc, 0x44, 0x62, 0x84, 0x75, 0xe6, 0x97, 0x3c, 0x24,
0xb6, 0x62, 0x43, 0xcb, 0x90, 0xa7, 0xcc, 0x25, 0x7e, 0x39, 0xc7, 0xb5, 0xdb, 0x92, 0x40, 0x2b,
0x50, 0xa0, 0xcc, 0x0d, 0x7a, 0xac, 0x9c, 0x17, 0xd7, 0x8a, 0x52, 0xf7, 0x38, 0x8a, 0xca, 0x85,
0xf8, 0x1e, 0x47, 0x11, 0xd2, 0xa1, 0xc8, 0x70, 0xd4, 0x25, 0xbe, 0xe3, 0x95, 0x6f, 0xac, 0x6a,
0xb5, 0xa2, 0x1d, 0xd3, 0xe8, 0x11, 0x40, 0xeb, 0x08, 0xb7, 0x3a, 0x61, 0x40, 0x7c, 0x56, 0x2e,
0xae, 0x6a, 0xb5, 0x52, 0xfd, 0xee, 0xa8, 0x59, 0x8d, 0x38, 0xe2, 0x76, 0x82, 0xdf, 0xd8, 0x07,
0x94, 0x8c, 0x0c, 0x0d, 0x03, 0x9f, 0xe2, 0x2b, 0x85, 0x66, 0x11, 0xb2, 0x21, 0x71, 0xcb, 0xd9,
0x55, 0xad, 0xb6, 0x60, 0xf3, 0xa3, 0xf1, 0x29, 0x2c, 0xee, 0x31, 0x27, 0x62, 0x93, 0x82, 0xae,
0xa5, 0x6b, 0x36, 0x9e, 0xc2, 0x52, 0x03, 0x7b, 0x78, 0x72, 0xf6, 0xa6, 0x51, 0xf4, 0x9b, 0x06,
0xb7, 0xa4, 0xa6, 0xb1, 0x9e, 0x6a, 0xd3, 0x7b, 0x9a, 0x89, 0x3d, 0x45, 0x55, 0x28, 0xe1, 0x57,
0x84, 0x35, 0x29, 0x73, 0x58, 0x8f, 0xaa, 0x18, 0x00, 0xbf, 0xda, 0x13, 0x37, 0xe8, 0x09, 0xcc,
0x73, 0x0a, 0xbb, 0x4d, 0x87, 0x89, 0x52, 0x28, 0xd5, 0x75, 0x53, 0x96, 0xad, 0x39, 0x28, 0x5b,
0xf3, 0xf9, 0xa0, 0x6c, 0x37, 0x8a, 0x27, 0xa7, 0xd5, 0xb9, 0x9f, 0xff, 0xa9, 0x6a, 0x76, 0x51,
0x8a, 0x3d, 0x61, 0xc6, 0xb7, 0xb0, 0x2c, 0x6d, 0xdf, 0x8d, 0x82, 0x16, 0xa6, 0x74, 0x86, 0x40,
0x8c, 0x7a, 0x60, 0x34, 0xe0, 0xd6, 0x53, 0x3c, 0x73, 0xa6, 0x1e, 0xc3, 0xed, 0x58, 0x8b, 0x0a,
0xf0, 0x1a, 0xe4, 0x78, 0xab, 0x0a, 0xf1, 0x52, 0xfd, 0x4e, 0xb2, 0x30, 0x8f, 0xd7, 0x55, 0x6d,
0x0a, 0x01, 0xc1, 0x66, 0xdc, 0x83, 0xc5, 0x2f, 0x08, 0x15, 0x2a, 0x62, 0x0f, 0x57, 0xa0, 0x70,
0x48, 0x3c, 0x86, 0x23, 0x69, 0x83, 0xad, 0x28, 0xa3, 0x01, 0x4b, 0x09, 0x5e, 0xf5, 0x9e, 0x05,
0x79, 0x31, 0x17, 0xcb, 0x9a, 0x68, 0xd0, 0x09, 0x0f, 0x4a, 0x3e, 0xe3, 0x27, 0x0d, 0x4a, 0x9f,
0x13, 0xcf, 0x9b, 0x25, 0x9e, 0xbc, 0x6f, 0x49, 0x9b, 0x77, 0xa7, 0x0c, 0xa9, 0xa2, 0x10, 0x82,
0xac, 0xe3, 0x79, 0xa2, 0x1e, 0x8a, 0x9f, 0xcd, 0xd9, 0x9c, 0xe0, 0x77, 0x3c, 0xf6, 0xbc, 0x08,
0x16, 0xf8, 0x5d, 0x48, 0xdc, 0x8d, 0x9b, 0x00, 0x21, 0x71, 0x9b, 0x41, 0xd4, 0x74, 0x3c, 0xcf,
0xf8, 0x53, 0x03, 0xb4, 0xf5, 0x0a, 0xb7, 0xae, 0x21, 0xd1, 0xf1, 0xf8, 0xc9, 0xbc, 0x79, 0xfc,
0x64, 0xc7, 0x8c, 0x9f, 0xdc, 0xd8, 0xf1, 0x93, 0x1f, 0x1a, 0x3f, 0x35, 0xc8, 0xd1, 0x10, 0xb7,
0xc4, 0xc0, 0x2a, 0xd5, 0x97, 0x47, 0x8a, 0xfa, 0x89, 0xdf, 0xb7, 0x05, 0x87, 0xf1, 0x2e, 0xfc,
0xef, 0x82, 0x57, 0x2a, 0x61, 0xaa, 0x16, 0xb5, 0xf3, 0x5a, 0xfc, 0x51, 0x83, 0x45, 0x1b, 0x53,
0xf2, 0x1d, 0xde, 0x65, 0xfd, 0x6b, 0x2d, 0x73, 0x1e, 0x8f, 0x97, 0xc4, 0x65, 0x47, 0xaa, 0x45,
0x25, 0xc1, 0xfd, 0x3e, 0xc2, 0xa4, 0x7d, 0x24, 0x5b, 0x73, 0xc1, 0x56, 0x94, 0xe1, 0xc1, 0xad,
0x4d, 0x2f, 0xa0, 0x78, 0x7b, 0xe7, 0xda, 0xad, 0x90, 0x59, 0x11, 0x85, 0xa1, 0xb2, 0xc2, 0xc7,
0xe5, 0xae, 0xd3, 0xa3, 0xf8, 0x1a, 0xc6, 0xa5, 0x8d, 0x69, 0xaf, 0x3b, 0xb3, 0xa2, 0x2d, 0xb8,
0xcd, 0xfb, 0x6b, 0x97, 0xb8, 0xb3, 0xd4, 0xa0, 0xf1, 0x8e, 0x6c, 0x69, 0xa9, 0x46, 0x25, 0x1d,
0x41, 0x2e, 0x24, 0xae, 0x6c, 0xd2, 0x05, 0x5b, 0x9c, 0x8d, 0xdf, 0x33, 0xf0, 0xff, 0xcd, 0x18,
0x99, 0x66, 0x34, 0x1e, 0x35, 0x61, 0x29, 0x74, 0x22, 0xec, 0xb3, 0x66, 0x02, 0x1d, 0x25, 0x8e,
0xd5, 0xf9, 0x74, 0xfd, 0xfb, 0xb4, 0x7a, 0x2f, 0xb1, 0x73, 0x04, 0x21, 0xf6, 0x63, 0x71, 0x6a,
0xb5, 0x83, 0x35, 0x97, 0xb4, 0x31, 0x65, 0x66, 0x43, 0xfc, 0xb3, 0x17, 0xa5, 0xb2, 0x73, 0xfb,
0xd0, 0x3e, 0xdc, 0x08, 0x42, 0x46, 0x02, 0x7f, 0xb0, 0x0b, 0x3c, 0x36, 0x27, 0x2d, 0x69, 0xe6,
0x1b, 0x5d, 0x33, 0x77, 0xa4, 0x8a, 0x2d, 0x9f, 0x45, 0x7d, 0x7b, 0xa0, 0x50, 0x7f, 0x00, 0x37,
0x93, 0x1f, 0x78, 0x09, 0x75, 0x70, 0x5f, 0x8d, 0x3f, 0x7e, 0xe4, 0x25, 0x74, 0xec, 0x78, 0x3d,
0x3c, 0x68, 0x6c, 0x41, 0x3c, 0xc8, 0x7c, 0xac, 0x19, 0xdf, 0xc0, 0xca, 0xf0, 0x53, 0x2a, 0xe8,
0x9f, 0x40, 0xe9, 0x7c, 0xef, 0x1a, 0x0c, 0xc8, 0xc9, 0xab, 0x42, 0x52, 0xc0, 0xf8, 0x1e, 0x96,
0xbe, 0x0a, 0x5d, 0x67, 0x66, 0x1c, 0x46, 0x75, 0x98, 0x8f, 0x30, 0x0d, 0x7a, 0x51, 0x0b, 0x53,
0xe1, 0xc0, 0xb8, 0xc1, 0x71, 0xce, 0x56, 0xff, 0xb5, 0x04, 0x79, 0x31, 0xe9, 0x51, 0x07, 0x0a,
0x72, 0x65, 0x41, 0x56, 0x4a, 0xc4, 0x87, 0x57, 0x3e, 0xfd, 0x83, 0xe9, 0x05, 0x54, 0xcc, 0x76,
0x20, 0x2f, 0x76, 0x18, 0x64, 0x4e, 0x16, 0x1d, 0x5e, 0x74, 0xf4, 0x95, 0x11, 0x87, 0xb6, 0xf8,
0x52, 0x8e, 0xda, 0x50, 0x90, 0x30, 0x9e, 0x66, 0xfd, 0xc8, 0xca, 0xa3, 0xbf, 0x3f, 0x8d, 0x40,
0x6c, 0xf9, 0x0b, 0x58, 0xb8, 0xb0, 0x2f, 0xa0, 0xfa, 0x34, 0xe2, 0x17, 0x31, 0xe7, 0x92, 0x4f,
0x1e, 0x40, 0xf6, 0x29, 0x66, 0x28, 0x45, 0xe8, 0xe2, 0x9e, 0xa1, 0xaf, 0x4d, 0xc9, 0xad, 0xde,
0x68, 0x43, 0x8e, 0x4f, 0x93, 0xb4, 0x7c, 0x0c, 0x2f, 0x11, 0xba, 0x35, 0x35, 0xbf, 0x7a, 0x68,
0x1b, 0x72, 0x7c, 0x2d, 0x40, 0xef, 0x4d, 0x16, 0x4c, 0xac, 0x0e, 0x63, 0x73, 0xde, 0x81, 0x1c,
0x47, 0x3e, 0x94, 0x52, 0x7e, 0xa3, 0x98, 0xaf, 0xaf, 0x5f, 0x42, 0x42, 0xd9, 0xbd, 0x07, 0xf3,
0x31, 0x78, 0xa6, 0x45, 0x69, 0x18, 0x65, 0xc7, 0x7a, 0xb0, 0x03, 0x37, 0x14, 0x12, 0xa6, 0x65,
0xf7, 0x22, 0x60, 0x4e, 0x50, 0x98, 0x17, 0x60, 0x97, 0x66, 0xe1, 0x30, 0x22, 0x8e, 0x55, 0xf8,
0x0c, 0x0a, 0x12, 0xf5, 0xd2, 0xfa, 0x6a, 0x04, 0x1b, 0xc7, 0xaa, 0x24, 0x50, 0x1c, 0x00, 0x17,
0x5a, 0x4b, 0x2f, 0x9f, 0x04, 0x4e, 0xea, 0xe6, 0xb4, 0xec, 0x2a, 0x69, 0x2f, 0x01, 0x12, 0xd0,
0x72, 0xff, 0x0a, 0x48, 0xa2, 0x7f, 0x78, 0x39, 0x21, 0xf5, 0xf0, 0x33, 0x28, 0xc8, 0x99, 0x9e,
0x16, 0xb6, 0x91, 0xc9, 0x3f, 0x2e, 0x6c, 0x1b, 0x5f, 0x9f, 0xbc, 0xae, 0xcc, 0xfd, 0xf5, 0xba,
0x32, 0xf7, 0xc3, 0x59, 0x45, 0x3b, 0x39, 0xab, 0x68, 0x7f, 0x9c, 0x55, 0xb4, 0x7f, 0xcf, 0x2a,
0xda, 0xfe, 0xa3, 0xab, 0xfd, 0x12, 0xf2, 0x50, 0x1c, 0x0e, 0x0a, 0xe2, 0x9d, 0xfb, 0xff, 0x05,
0x00, 0x00, 0xff, 0xff, 0x29, 0x59, 0x7a, 0x4c, 0x50, 0x11, 0x00, 0x00,
// 1191 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0xdd, 0x6e, 0x1b, 0xc5,
0x17, 0xcf, 0xc6, 0x1f, 0x75, 0x8e, 0x9b, 0x36, 0x99, 0x7f, 0xfe, 0xc1, 0x5d, 0x2a, 0x3b, 0xda,
0x0b, 0x30, 0x15, 0xd9, 0x25, 0x2e, 0xe2, 0x82, 0x56, 0x88, 0x26, 0x0e, 0x21, 0x02, 0x94, 0x74,
0x53, 0x10, 0xaa, 0x90, 0xac, 0x8d, 0x77, 0xe2, 0x8c, 0xb2, 0xde, 0xd9, 0xee, 0x8c, 0xd3, 0x06,
0x6e, 0xb8, 0xe2, 0x16, 0xde, 0x82, 0x77, 0xe0, 0x09, 0x72, 0xc9, 0x05, 0x17, 0x08, 0xa1, 0x40,
0xf3, 0x24, 0x68, 0x3e, 0xbc, 0xd9, 0xd8, 0xb1, 0xd7, 0xa9, 0x73, 0x93, 0xcc, 0xcc, 0x9e, 0x73,
0xe6, 0x9c, 0xdf, 0xf9, 0xf8, 0x8d, 0x0c, 0xeb, 0x1d, 0xc2, 0x0f, 0x7b, 0xfb, 0x76, 0x9b, 0x76,
0x9d, 0x36, 0x0d, 0xb9, 0x47, 0x42, 0x1c, 0xfb, 0xe9, 0xa5, 0x17, 0x11, 0x87, 0xe1, 0xf8, 0x98,
0xb4, 0x31, 0x73, 0xb8, 0xc7, 0x8e, 0x98, 0x73, 0xbc, 0xa6, 0x16, 0x76, 0x14, 0x53, 0x4e, 0xd1,
0xfd, 0x0b, 0x69, 0xbb, 0x2f, 0x69, 0x2b, 0x81, 0xe3, 0x35, 0xf3, 0xed, 0x0e, 0xa5, 0x9d, 0x00,
0x3b, 0x52, 0x76, 0xbf, 0x77, 0xe0, 0xe0, 0x6e, 0xc4, 0x4f, 0x94, 0xaa, 0x79, 0x6f, 0xf0, 0xa3,
0x17, 0xf6, 0x3f, 0x2d, 0x75, 0x68, 0x87, 0xca, 0xa5, 0x23, 0x56, 0xfa, 0xf4, 0xa3, 0x89, 0xfc,
0xe5, 0x27, 0x11, 0x66, 0x4e, 0x97, 0xf6, 0x42, 0xae, 0xf5, 0x1e, 0x5d, 0x43, 0xcf, 0xc7, 0xac,
0x1d, 0x93, 0x88, 0xd3, 0x58, 0x2b, 0x7f, 0x7c, 0x0d, 0x65, 0x11, 0xb7, 0xfc, 0xa3, 0x75, 0x6b,
0x83, 0x11, 0x72, 0xd2, 0xc5, 0x8c, 0x7b, 0xdd, 0x48, 0x09, 0x58, 0xa7, 0xb3, 0xb0, 0xb8, 0x11,
0x63, 0x8f, 0xe3, 0x67, 0x1e, 0x3b, 0x72, 0xf1, 0x8b, 0x1e, 0x66, 0x1c, 0x35, 0xe0, 0x76, 0x62,
0xbe, 0x45, 0xfc, 0xca, 0xec, 0x8a, 0x51, 0x9f, 0x5b, 0xbf, 0x7b, 0x7e, 0x56, 0x2b, 0x6f, 0xf4,
0xcf, 0xb7, 0x9b, 0x6e, 0x39, 0x11, 0xda, 0xf6, 0x91, 0x03, 0xc5, 0x98, 0x52, 0x7e, 0xc0, 0x2a,
0xb9, 0x95, 0x5c, 0xbd, 0xdc, 0x78, 0xcb, 0x4e, 0x25, 0x46, 0x7a, 0x67, 0x7f, 0x25, 0x20, 0x71,
0xb5, 0x18, 0x5a, 0x82, 0x02, 0xe3, 0x3e, 0x09, 0x2b, 0x79, 0x61, 0xdd, 0x55, 0x1b, 0xb4, 0x0c,
0x45, 0xc6, 0x7d, 0xda, 0xe3, 0x95, 0x82, 0x3c, 0xd6, 0x3b, 0x7d, 0x8e, 0xe3, 0xb8, 0x52, 0x4c,
0xce, 0x71, 0x1c, 0x23, 0x13, 0x4a, 0x1c, 0xc7, 0x5d, 0x12, 0x7a, 0x41, 0xe5, 0xd6, 0x8a, 0x51,
0x2f, 0xb9, 0xc9, 0x1e, 0x3d, 0x06, 0x68, 0x1f, 0xe2, 0xf6, 0x51, 0x44, 0x49, 0xc8, 0x2b, 0xa5,
0x15, 0xa3, 0x5e, 0x6e, 0xdc, 0x1f, 0x76, 0xab, 0x99, 0x20, 0xee, 0xa6, 0xe4, 0x91, 0x0d, 0xb7,
0x68, 0xc4, 0x09, 0x0d, 0x59, 0x65, 0x4e, 0xaa, 0x2e, 0xd9, 0x0a, 0x4d, 0xbb, 0x8f, 0xa6, 0xfd,
0x24, 0x3c, 0x71, 0xfb, 0x42, 0xd6, 0x73, 0x40, 0x69, 0x24, 0x59, 0x44, 0x43, 0x86, 0xdf, 0x08,
0xca, 0x05, 0xc8, 0x45, 0xc4, 0xaf, 0xe4, 0x56, 0x8c, 0xfa, 0xbc, 0x2b, 0x96, 0xd6, 0x67, 0xb0,
0xb0, 0xc7, 0xbd, 0x98, 0x8f, 0x4b, 0x92, 0x91, 0x6d, 0xd9, 0xda, 0x82, 0xc5, 0x26, 0x0e, 0xf0,
0xf8, 0x6c, 0x4f, 0x62, 0xe8, 0x37, 0x03, 0xee, 0x28, 0x4b, 0x23, 0x23, 0x35, 0x26, 0x8f, 0x74,
0x36, 0x89, 0x14, 0xd5, 0xa0, 0x8c, 0x5f, 0x11, 0xde, 0x62, 0xdc, 0xe3, 0x3d, 0xa6, 0x31, 0x00,
0x71, 0xb4, 0x27, 0x4f, 0xd0, 0x13, 0x98, 0x13, 0x3b, 0xec, 0xb7, 0x3c, 0x2e, 0x4b, 0xa7, 0xdc,
0x30, 0x87, 0x12, 0xf3, 0xac, 0x5f, 0xe6, 0xeb, 0xa5, 0xd3, 0xb3, 0xda, 0xcc, 0x2f, 0xff, 0xd4,
0x0c, 0xb7, 0xa4, 0xd4, 0x9e, 0x70, 0xeb, 0x3b, 0x58, 0x52, 0xbe, 0xef, 0xc6, 0xb4, 0x8d, 0x19,
0x9b, 0x02, 0x88, 0xe1, 0x08, 0xac, 0x26, 0xdc, 0xd9, 0xc2, 0x53, 0x67, 0xea, 0x53, 0xb8, 0x9b,
0x58, 0xd1, 0x00, 0xaf, 0x42, 0x5e, 0xb4, 0xb6, 0x54, 0x2f, 0x37, 0xee, 0xa5, 0x0b, 0xf9, 0x78,
0x4d, 0xd7, 0xb2, 0x54, 0x90, 0x62, 0xd6, 0x03, 0x58, 0xf8, 0x92, 0x30, 0x69, 0x22, 0x89, 0x70,
0x19, 0x8a, 0x07, 0x24, 0xe0, 0x38, 0x56, 0x3e, 0xb8, 0x7a, 0x67, 0x35, 0x61, 0x31, 0x25, 0xab,
0xef, 0x73, 0xa0, 0x20, 0xe7, 0x68, 0xc5, 0x90, 0x0d, 0x3d, 0xe6, 0x42, 0x25, 0x67, 0xfd, 0x6c,
0x40, 0xf9, 0x0b, 0x12, 0x04, 0xd3, 0xe0, 0x29, 0xfa, 0x9c, 0x74, 0x44, 0x37, 0x2b, 0x48, 0xf5,
0x0e, 0x21, 0xc8, 0x79, 0x41, 0x20, 0xeb, 0xa1, 0xf4, 0xf9, 0x8c, 0x2b, 0x36, 0xe2, 0x4c, 0x60,
0x2f, 0x8a, 0x60, 0x5e, 0x9c, 0x45, 0xc4, 0x5f, 0xbf, 0x0d, 0x10, 0x11, 0xbf, 0x45, 0xe3, 0x96,
0x17, 0x04, 0xd6, 0x1f, 0x06, 0xa0, 0xcd, 0x57, 0xb8, 0x7d, 0x03, 0x89, 0x4e, 0xc6, 0xd5, 0xec,
0xd5, 0xe3, 0x2a, 0x37, 0x62, 0x5c, 0xe5, 0x47, 0x8e, 0xab, 0xc2, 0xc0, 0xb8, 0xaa, 0x43, 0x9e,
0x45, 0xb8, 0x2d, 0x07, 0xdc, 0xa8, 0x69, 0x23, 0x25, 0xac, 0x77, 0xe1, 0x7f, 0x97, 0xa2, 0xd2,
0x09, 0xd3, 0xb5, 0x68, 0x5c, 0xd4, 0xe2, 0x4f, 0x06, 0x2c, 0xb8, 0x98, 0x91, 0xef, 0xf1, 0x2e,
0x3f, 0xb9, 0xd1, 0x32, 0x17, 0x78, 0xbc, 0x24, 0x3e, 0x3f, 0xd4, 0x2d, 0xaa, 0x36, 0x22, 0xee,
0x43, 0x4c, 0x3a, 0x87, 0xaa, 0x35, 0xe7, 0x5d, 0xbd, 0xb3, 0x02, 0xb8, 0xb3, 0x11, 0x50, 0x86,
0xb7, 0x77, 0x6e, 0xdc, 0x0b, 0x95, 0x15, 0x59, 0x18, 0x3a, 0x2b, 0x62, 0x5c, 0xee, 0x7a, 0x3d,
0x86, 0x6f, 0x60, 0x5c, 0xba, 0x98, 0xf5, 0xba, 0x53, 0x1b, 0xda, 0x84, 0xbb, 0xa2, 0xbf, 0x76,
0x89, 0x3f, 0x4d, 0x0d, 0x5a, 0xef, 0xa8, 0x96, 0x56, 0x66, 0x74, 0xd2, 0x11, 0xe4, 0x23, 0xe2,
0xab, 0x26, 0x9d, 0x77, 0xe5, 0xda, 0xfa, 0xdb, 0x80, 0xff, 0x6f, 0x24, 0x4c, 0x36, 0xa5, 0xf3,
0xa8, 0x05, 0x8b, 0x91, 0x17, 0xe3, 0x90, 0xb7, 0x52, 0x6c, 0xaa, 0x78, 0xac, 0x21, 0xa6, 0xeb,
0x5f, 0x67, 0xb5, 0x07, 0xa9, 0x37, 0x0a, 0x8d, 0x70, 0x98, 0xa8, 0x33, 0xa7, 0x43, 0x57, 0x7d,
0xd2, 0xc1, 0x8c, 0xdb, 0x4d, 0xf9, 0xcf, 0x5d, 0x50, 0xc6, 0x36, 0xae, 0x64, 0xda, 0xdc, 0x24,
0x4c, 0xfb, 0x2d, 0x2c, 0x0f, 0x46, 0xa7, 0xc1, 0xf8, 0x04, 0xca, 0x17, 0xef, 0xa7, 0xfe, 0xe0,
0x1a, 0x4f, 0xf9, 0x69, 0x05, 0xeb, 0x07, 0x58, 0xfc, 0x3a, 0xf2, 0xbd, 0xa9, 0xf9, 0x11, 0x35,
0x60, 0x2e, 0xc6, 0x8c, 0xf6, 0xe2, 0x36, 0x66, 0x12, 0xab, 0x51, 0x41, 0x5d, 0x88, 0x35, 0x7e,
0x2d, 0x43, 0x41, 0x4e, 0x60, 0x74, 0x04, 0x45, 0xf5, 0x94, 0x40, 0x8e, 0x3d, 0xee, 0x79, 0x6b,
0x0f, 0x3d, 0xdd, 0xcc, 0x0f, 0x26, 0x57, 0xd0, 0x98, 0xed, 0x40, 0x41, 0xbe, 0x2d, 0x90, 0x3d,
0x5e, 0x75, 0xf0, 0x01, 0x62, 0x2e, 0x0f, 0x05, 0xb4, 0x29, 0x1e, 0xd7, 0xa8, 0x03, 0x45, 0x45,
0xaf, 0x59, 0xde, 0x0f, 0x3d, 0x45, 0xcc, 0xf7, 0x27, 0x51, 0x48, 0x3c, 0x7f, 0x01, 0xf3, 0x97,
0x78, 0x1c, 0x35, 0x26, 0x51, 0xbf, 0xcc, 0x05, 0xd7, 0xbc, 0x72, 0x1f, 0x72, 0x5b, 0x98, 0xa3,
0x0c, 0xa5, 0xcb, 0xfc, 0x6f, 0xae, 0x4e, 0x28, 0xad, 0xef, 0xe8, 0x40, 0x5e, 0x74, 0x79, 0x56,
0x3e, 0x06, 0xc9, 0xdd, 0x74, 0x26, 0x96, 0xd7, 0x17, 0x6d, 0x43, 0x5e, 0xd0, 0x35, 0x7a, 0x6f,
0xbc, 0x62, 0x8a, 0xd2, 0x47, 0xe6, 0xfc, 0x08, 0xf2, 0x82, 0x91, 0x50, 0x46, 0xf9, 0x0d, 0x73,
0xb1, 0xb9, 0x76, 0x0d, 0x0d, 0xed, 0xf7, 0x1e, 0xcc, 0x25, 0xa4, 0x96, 0x85, 0xd2, 0x20, 0xfb,
0x8d, 0x8c, 0x60, 0x07, 0x6e, 0x69, 0x86, 0xca, 0xca, 0xee, 0x65, 0x22, 0x1b, 0x63, 0xb0, 0x20,
0x49, 0x28, 0xcb, 0xc3, 0x41, 0xa6, 0x1a, 0x69, 0xf0, 0x29, 0x14, 0x15, 0x1b, 0x65, 0xf5, 0xd5,
0x10, 0x67, 0x8d, 0x34, 0x49, 0xa0, 0xd4, 0x27, 0x14, 0xb4, 0x9a, 0x5d, 0x3e, 0x29, 0xfe, 0x32,
0xed, 0x49, 0xc5, 0x75, 0xd2, 0x5e, 0x02, 0xa4, 0x46, 0xfe, 0xc3, 0x0c, 0x88, 0xaf, 0x22, 0x2f,
0xf3, 0xc3, 0xeb, 0x29, 0xe9, 0x8b, 0x9f, 0x42, 0x51, 0xcd, 0xf4, 0x2c, 0xd8, 0x86, 0x26, 0xff,
0x28, 0xd8, 0xd6, 0xbf, 0x39, 0x7d, 0x5d, 0x9d, 0xf9, 0xf3, 0x75, 0x75, 0xe6, 0xc7, 0xf3, 0xaa,
0x71, 0x7a, 0x5e, 0x35, 0x7e, 0x3f, 0xaf, 0x1a, 0xff, 0x9e, 0x57, 0x8d, 0xe7, 0x8f, 0xdf, 0xec,
0x17, 0x8d, 0x47, 0x72, 0xb1, 0x5f, 0x94, 0xf7, 0x3c, 0xfc, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x7e,
0x07, 0x52, 0x7c, 0x18, 0x11, 0x00, 0x00,
}

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

@ -72,6 +72,8 @@ message CreateTaskRequest {
bool terminal = 7;
containerd.types.Descriptor checkpoint = 8;
google.protobuf.Any options = 9;
}
message CreateTaskResponse {
@ -184,7 +186,7 @@ message ListPidsResponse{
message CheckpointTaskRequest {
string container_id = 1;
string parent_checkpoint = 2 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false];
map<string, string> options = 3;
google.protobuf.Any options = 3;
}
message CheckpointTaskResponse {

108
checkpoint_test.go
View File

@ -1,8 +1,14 @@
package containerd
import (
"path/filepath"
"syscall"
"testing"
tasks "github.com/containerd/containerd/api/services/tasks/v1"
"github.com/containerd/containerd/linux/runcopts"
"github.com/gogo/protobuf/proto"
protobuf "github.com/gogo/protobuf/types"
)
func TestCheckpointRestore(t *testing.T) {
@ -200,3 +206,105 @@ func TestCheckpointRestoreNewContainer(t *testing.T) {
}
<-statusC
}
func TestCheckpointLeaveRunning(t *testing.T) {
if testing.Short() {
t.Skip()
}
if !supportsCriu {
t.Skip("system does not have criu installed")
}
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", "100"))
if err != nil {
t.Error(err)
return
}
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
}()
if err := task.Start(ctx); err != nil {
t.Error(err)
return
}
if _, err := task.Checkpoint(ctx); err != nil {
t.Error(err)
return
}
status, err := task.Status(ctx)
if err != nil {
t.Error(err)
return
}
if status != Running {
t.Errorf("expected status %q but received %q", Running, status)
return
}
if err := task.Kill(ctx, syscall.SIGKILL); err != nil {
t.Error(err)
return
}
<-statusC
}
func WithExit(r *tasks.CheckpointTaskRequest) error {
a, err := marshal(&runcopts.CheckpointOptions{
Exit: true,
}, "CheckpointOptions")
if err != nil {
return err
}
r.Options = a
return nil
}
func marshal(m proto.Message, name string) (*protobuf.Any, error) {
data, err := proto.Marshal(m)
if err != nil {
return nil, err
}
return &protobuf.Any{
TypeUrl: filepath.Join(runcopts.URIBase, name),
Value: data,
}, nil
}

5
client.go
View File

@ -195,10 +195,13 @@ func WithNewReadonlyRootFS(id string, i Image) NewContainerOpts {
}
}
func WithRuntime(name string) NewContainerOpts {
// WithRuntime allows a user to specify the runtime name and additional options that should
// be used to create tasks for the container
func WithRuntime(name string, options map[string]string) NewContainerOpts {
return func(ctx context.Context, client *Client, c *containers.Container) error {
c.Runtime = &containers.Container_Runtime{
Name: name,
Options: options,
}
return nil
}

29
cmd/ctr/checkpoint.go
View File

@ -2,8 +2,13 @@ package main
import (
"fmt"
"path/filepath"
"github.com/containerd/containerd"
tasks "github.com/containerd/containerd/api/services/tasks/v1"
"github.com/containerd/containerd/linux/runcopts"
"github.com/gogo/protobuf/proto"
protobuf "github.com/gogo/protobuf/types"
"github.com/pkg/errors"
"github.com/urfave/cli"
)
@ -42,7 +47,7 @@ var checkpointCommand = cli.Command{
}
var opts []containerd.CheckpointOpts
if context.Bool("exit") {
opts = append(opts, containerd.WithExit)
opts = append(opts, WithExit)
}
checkpoint, err := task.Checkpoint(ctx, opts...)
if err != nil {
@ -52,3 +57,25 @@ var checkpointCommand = cli.Command{
return nil
},
}
func WithExit(r *tasks.CheckpointTaskRequest) error {
a, err := marshal(&runcopts.CheckpointOptions{
Exit: true,
}, "CheckpointOptions")
if err != nil {
return err
}
r.Options = a
return nil
}
func marshal(m proto.Message, name string) (*protobuf.Any, error) {
data, err := proto.Marshal(m)
if err != nil {
return nil, err
}
return &protobuf.Any{
TypeUrl: filepath.Join(runcopts.URIBase, name),
Value: data,
}, nil
}

3
linux/runcopts/options.go Normal file
View File

@ -0,0 +1,3 @@
package runcopts
const URIBase = "containerd.io/linux/runc"

1153
linux/runcopts/runc.pb.go Normal file
View File

File diff suppressed because it is too large Load Diff

33
linux/runcopts/runc.proto Normal file
View File

@ -0,0 +1,33 @@
syntax = "proto3";
package containerd.linux.runc;
import "gogoproto/gogo.proto";
option go_package = "github.com/containerd/containerd/linux/runcopts;runcopts";
message RuncOptions {
string criu_path = 1;
string systemd_cgroup = 2;
}
message CreateOptions {
bool no_pivot_root = 1;
bool open_tcp = 2;
bool external_unix_sockets = 3;
bool terminal = 4;
bool file_locks = 5;
repeated string empty_namespaces = 6;
string cgroups_mode = 7;
bool no_new_keyring = 8;
}
message CheckpointOptions {
bool exit = 1;
bool open_tcp = 2;
bool external_unix_sockets = 3;
bool terminal = 4;
bool file_locks = 5;
repeated string empty_namespaces = 6;
string cgroups_mode = 7;
}

4
linux/runtime.go
View File

@ -25,6 +25,7 @@ import (
"github.com/containerd/containerd/plugin"
"github.com/containerd/containerd/runtime"
runc "github.com/containerd/go-runc"
protobuf "github.com/gogo/protobuf/types"
google_protobuf "github.com/golang/protobuf/ptypes/empty"
"github.com/pkg/errors"
@ -171,6 +172,9 @@ func (r *Runtime) Create(ctx context.Context, id string, opts runtime.CreateOpts
Stderr: opts.IO.Stderr,
Terminal: opts.IO.Terminal,
Checkpoint: opts.Checkpoint,
Options: &protobuf.Any{
Value: opts.Options,
},
}
for _, m := range opts.Rootfs {
sopts.Rootfs = append(sopts.Rootfs, &types.Mount{

37
linux/shim/init.go
View File

@ -17,12 +17,14 @@ import (
"golang.org/x/sys/unix"
"github.com/containerd/console"
"github.com/containerd/containerd/linux/runcopts"
shimapi "github.com/containerd/containerd/linux/shim/v1"
"github.com/containerd/containerd/log"
"github.com/containerd/containerd/mount"
"github.com/containerd/containerd/runtime"
"github.com/containerd/fifo"
runc "github.com/containerd/go-runc"
"github.com/gogo/protobuf/proto"
specs "github.com/opencontainers/runtime-spec/specs-go"
"github.com/pkg/errors"
)
@ -54,6 +56,12 @@ type initProcess struct {
}
func newInitProcess(context context.Context, path, namespace string, r *shimapi.CreateTaskRequest) (*initProcess, error) {
var options runcopts.CreateOptions
if r.Options != nil {
if err := proto.Unmarshal(r.Options.Value, &options); err != nil {
return nil, err
}
}
for _, rm := range r.Rootfs {
m := &mount.Mount{
Type: rm.Type,
@ -107,8 +115,7 @@ func newInitProcess(context context.Context, path, namespace string, r *shimapi.
},
PidFile: pidFile,
IO: io,
// TODO: implement runtime options
//NoPivot: r.NoPivot,
NoPivot: options.NoPivotRoot,
Detach: true,
NoSubreaper: true,
}
@ -119,7 +126,8 @@ func newInitProcess(context context.Context, path, namespace string, r *shimapi.
opts := &runc.CreateOpts{
PidFile: pidFile,
IO: io,
// NoPivot: r.NoPivot,
NoPivot: options.NoPivotRoot,
NoNewKeyring: options.NoNewKeyring,
}
if socket != nil {
opts.ConsoleSocket = socket
@ -256,25 +264,26 @@ func (p *initProcess) Stdin() io.Closer {
}
func (p *initProcess) Checkpoint(context context.Context, r *shimapi.CheckpointTaskRequest) error {
var options runcopts.CheckpointOptions
if r.Options != nil {
if err := proto.Unmarshal(r.Options.Value, &options); err != nil {
return err
}
}
var actions []runc.CheckpointAction
/*
if !r.Exit {
if !options.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.Path,
/*
AllowOpenTCP: r.AllowTcp,
AllowExternalUnixSockets: r.AllowUnixSockets,
AllowTerminal: r.AllowTerminal,
FileLocks: r.FileLocks,
EmptyNamespaces: r.EmptyNamespaces,
*/
AllowOpenTCP: options.OpenTcp,
AllowExternalUnixSockets: options.ExternalUnixSockets,
AllowTerminal: options.Terminal,
FileLocks: options.FileLocks,
EmptyNamespaces: options.EmptyNamespaces,
}, actions...); err != nil {
dumpLog := filepath.Join(p.bundle, "criu-dump.log")
if cerr := copyFile(dumpLog, filepath.Join(work, "dump.log")); cerr != nil {

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

@ -50,7 +50,6 @@ 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"
@ -77,6 +76,7 @@ type CreateTaskRequest struct {
Stderr string `protobuf:"bytes,8,opt,name=stderr,proto3" json:"stderr,omitempty"`
Checkpoint string `protobuf:"bytes,9,opt,name=checkpoint,proto3" json:"checkpoint,omitempty"`
ParentCheckpoint string `protobuf:"bytes,10,opt,name=parent_checkpoint,json=parentCheckpoint,proto3" json:"parent_checkpoint,omitempty"`
Options *google_protobuf.Any `protobuf:"bytes,11,opt,name=options" json:"options,omitempty"`
}
func (m *CreateTaskRequest) Reset() { *m = CreateTaskRequest{} }
@ -192,7 +192,7 @@ func (*ListPidsResponse) Descriptor() ([]byte, []int) { return fileDescriptorShi
type CheckpointTaskRequest struct {
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"`
Options *google_protobuf.Any `protobuf:"bytes,2,opt,name=options" json:"options,omitempty"`
}
func (m *CheckpointTaskRequest) Reset() { *m = CheckpointTaskRequest{} }
@ -925,6 +925,16 @@ func (m *CreateTaskRequest) MarshalTo(dAtA []byte) (int, error) {
i = encodeVarintShim(dAtA, i, uint64(len(m.ParentCheckpoint)))
i += copy(dAtA[i:], m.ParentCheckpoint)
}
if m.Options != nil {
dAtA[i] = 0x5a
i++
i = encodeVarintShim(dAtA, i, uint64(m.Options.Size()))
n1, err := m.Options.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n1
}
return i, nil
}
@ -979,11 +989,11 @@ func (m *DeleteResponse) MarshalTo(dAtA []byte) (int, error) {
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:])
n2, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ExitedAt, dAtA[i:])
if err != nil {
return 0, err
}
i += n1
i += n2
return i, nil
}
@ -1057,11 +1067,11 @@ func (m *ExecProcessRequest) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x2a
i++
i = encodeVarintShim(dAtA, i, uint64(m.Spec.Size()))
n2, err := m.Spec.MarshalTo(dAtA[i:])
n3, err := m.Spec.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n2
i += n3
}
return i, nil
}
@ -1313,21 +1323,21 @@ func (m *ListPidsResponse) MarshalTo(dAtA []byte) (int, error) {
var l int
_ = l
if len(m.Pids) > 0 {
dAtA4 := make([]byte, len(m.Pids)*10)
var j3 int
dAtA5 := make([]byte, len(m.Pids)*10)
var j4 int
for _, num := range m.Pids {
for num >= 1<<7 {
dAtA4[j3] = uint8(uint64(num)&0x7f | 0x80)
dAtA5[j4] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j3++
j4++
}
dAtA4[j3] = uint8(num)
j3++
dAtA5[j4] = uint8(num)
j4++
}
dAtA[i] = 0xa
i++
i = encodeVarintShim(dAtA, i, uint64(j3))
i += copy(dAtA[i:], dAtA4[:j3])
i = encodeVarintShim(dAtA, i, uint64(j4))
i += copy(dAtA[i:], dAtA5[:j4])
}
return i, nil
}
@ -1353,22 +1363,15 @@ func (m *CheckpointTaskRequest) MarshalTo(dAtA []byte) (int, error) {
i = encodeVarintShim(dAtA, i, uint64(len(m.Path)))
i += copy(dAtA[i:], m.Path)
}
if len(m.Options) > 0 {
for k, _ := range m.Options {
if m.Options != nil {
dAtA[i] = 0x12
i++
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 = 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)
i = encodeVarintShim(dAtA, i, uint64(m.Options.Size()))
n6, err := m.Options.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n6
}
return i, nil
}
@ -1433,11 +1436,11 @@ func (m *UpdateTaskRequest) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0xa
i++
i = encodeVarintShim(dAtA, i, uint64(m.Resources.Size()))
n5, err := m.Resources.MarshalTo(dAtA[i:])
n7, err := m.Resources.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n5
i += n7
}
return i, nil
}
@ -1513,6 +1516,10 @@ func (m *CreateTaskRequest) Size() (n int) {
if l > 0 {
n += 1 + l + sovShim(uint64(l))
}
if m.Options != nil {
l = m.Options.Size()
n += 1 + l + sovShim(uint64(l))
}
return n
}
@ -1695,13 +1702,9 @@ func (m *CheckpointTaskRequest) Size() (n int) {
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))
}
if m.Options != nil {
l = m.Options.Size()
n += 1 + l + sovShim(uint64(l))
}
return n
}
@ -1759,6 +1762,7 @@ func (this *CreateTaskRequest) String() string {
`Stderr:` + fmt.Sprintf("%v", this.Stderr) + `,`,
`Checkpoint:` + fmt.Sprintf("%v", this.Checkpoint) + `,`,
`ParentCheckpoint:` + fmt.Sprintf("%v", this.ParentCheckpoint) + `,`,
`Options:` + strings.Replace(fmt.Sprintf("%v", this.Options), "Any", "google_protobuf.Any", 1) + `,`,
`}`,
}, "")
return s
@ -1896,19 +1900,9 @@ func (this *CheckpointTaskRequest) 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{`&CheckpointTaskRequest{`,
`Path:` + fmt.Sprintf("%v", this.Path) + `,`,
`Options:` + mapStringForOptions + `,`,
`Options:` + strings.Replace(fmt.Sprintf("%v", this.Options), "Any", "google_protobuf.Any", 1) + `,`,
`}`,
}, "")
return s
@ -2262,6 +2256,39 @@ func (m *CreateTaskRequest) Unmarshal(dAtA []byte) error {
}
m.ParentCheckpoint = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 11:
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 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.Options == nil {
m.Options = &google_protobuf.Any{}
}
if err := m.Options.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipShim(dAtA[iNdEx:])
@ -3661,94 +3688,11 @@ func (m *CheckpointTaskRequest) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
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)
m.Options = &google_protobuf.Any{}
}
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
if err := m.Options.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
@ -4084,77 +4028,75 @@ func init() {
}
var fileDescriptorShim = []byte{
// 1148 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0x4f, 0x73, 0xdb, 0x44,
0x14, 0xaf, 0x6c, 0x47, 0xb1, 0x9f, 0x71, 0x48, 0xb6, 0x69, 0x50, 0x5d, 0xc6, 0xc9, 0xe8, 0x50,
0xcc, 0x74, 0x2a, 0x35, 0x0e, 0x6d, 0x43, 0x38, 0xe5, 0xdf, 0x30, 0x19, 0xc8, 0xd4, 0xa3, 0xb4,
0x30, 0xc3, 0x0c, 0x64, 0x14, 0x6b, 0x63, 0xef, 0x44, 0x96, 0x54, 0xed, 0xca, 0xc4, 0x9c, 0x38,
0x71, 0xe6, 0x23, 0x70, 0xe0, 0xc6, 0x67, 0xe0, 0x4c, 0x8e, 0x1c, 0x39, 0x15, 0x9a, 0x4f, 0xc2,
0xec, 0x6a, 0x15, 0xc9, 0x76, 0x84, 0xed, 0x0e, 0x97, 0x78, 0xdf, 0xee, 0xfb, 0xbd, 0x7d, 0xfb,
0x7b, 0xff, 0x14, 0xf8, 0xb4, 0x4b, 0x58, 0x2f, 0x3a, 0x33, 0x3a, 0x7e, 0xdf, 0xec, 0xf8, 0x1e,
0xb3, 0x89, 0x87, 0x43, 0x27, 0xbb, 0x74, 0x89, 0x17, 0x5d, 0x9a, 0xb4, 0x47, 0xfa, 0xe6, 0x60,
0x53, 0xfc, 0x1a, 0x41, 0xe8, 0x33, 0x1f, 0x6d, 0xa4, 0x4a, 0x46, 0x18, 0x79, 0x8c, 0xf4, 0xb1,
0x21, 0x94, 0x0d, 0xa1, 0x34, 0xd8, 0xac, 0xdf, 0xef, 0xfa, 0x7e, 0xd7, 0xc5, 0xa6, 0xd0, 0x3f,
0x8b, 0xce, 0x4d, 0xdb, 0x1b, 0xc6, 0xe0, 0xfa, 0x83, 0xf1, 0x23, 0xdc, 0x0f, 0x58, 0x72, 0xb8,
0xda, 0xf5, 0xbb, 0xbe, 0x58, 0x9a, 0x7c, 0x25, 0x77, 0xd7, 0xc7, 0x21, 0xfc, 0x46, 0xca, 0xec,
0x7e, 0x20, 0x15, 0x9e, 0x4d, 0x7d, 0x8b, 0x1d, 0x10, 0x93, 0x0d, 0x03, 0x4c, 0xcd, 0xbe, 0x1f,
0x79, 0x4c, 0xe2, 0x76, 0xe6, 0xc0, 0x31, 0x9b, 0x5e, 0x88, 0x3f, 0x12, 0x7b, 0x38, 0x13, 0x96,
0xe2, 0x70, 0x40, 0x3a, 0x98, 0x9a, 0x78, 0x80, 0x3d, 0x46, 0x39, 0x91, 0x09, 0x63, 0xc2, 0x8c,
0xfe, 0x7b, 0x01, 0x56, 0xf6, 0x43, 0x6c, 0x33, 0xfc, 0xd2, 0xa6, 0x17, 0x16, 0x7e, 0x1d, 0x61,
0xca, 0xd0, 0x1a, 0x14, 0x88, 0xa3, 0x29, 0x1b, 0x4a, 0xb3, 0xb2, 0xa7, 0x5e, 0xbf, 0x59, 0x2f,
0x1c, 0x1d, 0x58, 0x05, 0xe2, 0xa0, 0x35, 0x50, 0xcf, 0x22, 0xcf, 0x71, 0xb1, 0x56, 0xe0, 0x67,
0x96, 0x94, 0x90, 0x06, 0x8b, 0xd2, 0xac, 0x56, 0x14, 0x07, 0x89, 0x88, 0x4c, 0x50, 0x43, 0xdf,
0x67, 0xe7, 0x54, 0x2b, 0x6d, 0x14, 0x9b, 0xd5, 0xd6, 0x07, 0x46, 0x26, 0x78, 0xe2, 0x65, 0xc6,
0x31, 0x67, 0xc4, 0x92, 0x6a, 0xa8, 0x0e, 0x65, 0x86, 0xc3, 0x3e, 0xf1, 0x6c, 0x57, 0x5b, 0xd8,
0x50, 0x9a, 0x65, 0xeb, 0x46, 0x46, 0xab, 0xb0, 0x40, 0x99, 0x43, 0x3c, 0x4d, 0x15, 0x97, 0xc4,
0x02, 0x77, 0x8a, 0x32, 0xc7, 0x8f, 0x98, 0xb6, 0x18, 0x3b, 0x15, 0x4b, 0x72, 0x1f, 0x87, 0xa1,
0x56, 0xbe, 0xd9, 0xc7, 0x61, 0x88, 0x1a, 0x00, 0x9d, 0x1e, 0xee, 0x5c, 0x04, 0x3e, 0xf1, 0x98,
0x56, 0x11, 0x67, 0x99, 0x1d, 0xf4, 0x08, 0x56, 0x02, 0x3b, 0xc4, 0x1e, 0x3b, 0xcd, 0xa8, 0x81,
0x50, 0x5b, 0x8e, 0x0f, 0xf6, 0x6f, 0xf6, 0xf5, 0x87, 0x80, 0xb2, 0xf4, 0xd1, 0xc0, 0xf7, 0x28,
0x46, 0xcb, 0x50, 0x0c, 0x24, 0x81, 0x35, 0x8b, 0x2f, 0xf5, 0x9f, 0x14, 0x58, 0x3a, 0xc0, 0x2e,
0x66, 0x38, 0x5f, 0x09, 0xad, 0x43, 0x15, 0x5f, 0x12, 0x76, 0x4a, 0x99, 0xcd, 0x22, 0x2a, 0x38,
0xae, 0x59, 0xc0, 0xb7, 0x4e, 0xc4, 0x0e, 0xda, 0x85, 0x0a, 0x97, 0xb0, 0x73, 0x6a, 0x33, 0xc1,
0x74, 0xb5, 0x55, 0x37, 0xe2, 0xec, 0x34, 0x92, 0xec, 0x34, 0x5e, 0x26, 0xd9, 0xb9, 0x57, 0xbe,
0x7a, 0xb3, 0x7e, 0xe7, 0xe7, 0xbf, 0xd7, 0x15, 0xab, 0x1c, 0xc3, 0x76, 0x99, 0xde, 0x84, 0xd5,
0xd8, 0x8f, 0x76, 0xe8, 0x77, 0x30, 0xa5, 0x49, 0xc8, 0x27, 0x5d, 0xfe, 0x45, 0x01, 0x74, 0x78,
0x89, 0x3b, 0x63, 0x8a, 0xd9, 0x00, 0x29, 0x79, 0x01, 0x2a, 0xdc, 0x1e, 0xa0, 0x62, 0x4e, 0x80,
0x4a, 0x23, 0x01, 0x6a, 0x42, 0x89, 0x06, 0xb8, 0x23, 0xc2, 0x5f, 0x6d, 0xad, 0x4e, 0x3c, 0x70,
0xd7, 0x1b, 0x5a, 0x42, 0x43, 0xff, 0x08, 0xee, 0x8e, 0x78, 0x98, 0x4b, 0xbf, 0x05, 0xcb, 0x16,
0xa6, 0xe4, 0x07, 0xdc, 0x66, 0xc3, 0xdc, 0x17, 0x73, 0xf7, 0xbf, 0x27, 0x0e, 0xeb, 0x49, 0xe6,
0x63, 0x81, 0xbb, 0xd9, 0xc3, 0xa4, 0xdb, 0x8b, 0xdd, 0xaf, 0x59, 0x52, 0xd2, 0x7f, 0x2d, 0x40,
0x8d, 0xc7, 0x25, 0x8d, 0xe8, 0xbc, 0x65, 0x23, 0x3d, 0x28, 0xa6, 0x1e, 0x6c, 0x71, 0x4a, 0x44,
0xf0, 0x39, 0x25, 0x4b, 0xad, 0x07, 0xd9, 0x72, 0x19, 0x6c, 0xca, 0x8a, 0x89, 0xb3, 0xc1, 0x92,
0xaa, 0x68, 0x07, 0x2a, 0x41, 0xcc, 0x00, 0xa6, 0xda, 0x82, 0x28, 0xb3, 0x0f, 0x6f, 0xc5, 0x25,
0x3c, 0xa5, 0xea, 0xff, 0x53, 0x49, 0x65, 0x73, 0xa2, 0x32, 0x9a, 0x13, 0xfa, 0x11, 0x54, 0xbf,
0x20, 0xae, 0x9b, 0xb6, 0x16, 0x95, 0x92, 0x6e, 0x92, 0x3c, 0x35, 0x4b, 0x4a, 0x9c, 0x0b, 0xdb,
0x75, 0x05, 0x41, 0x65, 0x8b, 0x2f, 0x27, 0xd9, 0xd1, 0xb7, 0x61, 0x69, 0xdf, 0xf5, 0x29, 0x3e,
0x7a, 0xf1, 0x9f, 0x31, 0x4c, 0x53, 0xb0, 0x2c, 0x1f, 0xa4, 0x7f, 0x0c, 0xef, 0x7f, 0x49, 0x28,
0x6b, 0x13, 0x87, 0x4e, 0xe9, 0x71, 0xfa, 0x43, 0x58, 0x4e, 0x55, 0x65, 0x60, 0x11, 0x94, 0x02,
0xe2, 0x50, 0x4d, 0xd9, 0x28, 0x36, 0x6b, 0x96, 0x58, 0xeb, 0x7f, 0x28, 0x70, 0x2f, 0x6d, 0x04,
0xd9, 0xee, 0xc9, 0xb5, 0x6d, 0xd6, 0x8b, 0x6d, 0x5b, 0x62, 0x8d, 0xbe, 0x83, 0x45, 0x3f, 0x60,
0xc4, 0xf7, 0x78, 0x59, 0xf3, 0x08, 0x1d, 0x18, 0xd3, 0xa6, 0x98, 0x71, 0xab, 0x75, 0xe3, 0x45,
0x6c, 0xe6, 0xd0, 0x63, 0xe1, 0xd0, 0x4a, 0x8c, 0xd6, 0x77, 0xe0, 0xbd, 0xec, 0x01, 0x27, 0xe6,
0x02, 0x0f, 0xa5, 0x0b, 0x7c, 0xc9, 0x89, 0x19, 0xd8, 0x6e, 0x94, 0xe4, 0x60, 0x2c, 0xec, 0x14,
0xb6, 0x15, 0xfd, 0x31, 0x2c, 0x9f, 0xf4, 0x48, 0xff, 0xc8, 0x3b, 0xf7, 0x6f, 0x5e, 0x7c, 0x1f,
0xca, 0xdc, 0x8d, 0xd3, 0x94, 0xdd, 0x45, 0x2e, 0xb7, 0x89, 0xa3, 0xdf, 0x83, 0xbb, 0x27, 0x2c,
0xc4, 0x76, 0xff, 0x50, 0xcc, 0x14, 0xe9, 0x97, 0xfe, 0x39, 0xac, 0xbc, 0x0a, 0x9c, 0xb1, 0x41,
0xd2, 0x82, 0x4a, 0x88, 0xa9, 0x1f, 0x85, 0x1d, 0x4c, 0x85, 0x9d, 0xbc, 0x7a, 0x4e, 0xd5, 0x5a,
0xbf, 0x55, 0xa1, 0xc4, 0xfd, 0x41, 0x6d, 0x58, 0x10, 0xf5, 0x85, 0xd6, 0x26, 0x20, 0x87, 0x7c,
0x68, 0xd7, 0xcd, 0xe9, 0x1c, 0x8e, 0x16, 0x28, 0x05, 0x35, 0xee, 0xd6, 0x68, 0x6b, 0x06, 0xfa,
0xc7, 0xc7, 0x62, 0xfd, 0x93, 0xf9, 0x40, 0xf2, 0xd2, 0xe7, 0xe2, 0x19, 0x21, 0xcb, 0x7d, 0x46,
0xce, 0x3e, 0xb2, 0x40, 0x8d, 0x5b, 0x75, 0x2e, 0xf2, 0xc9, 0x74, 0x87, 0xc6, 0x86, 0xce, 0x10,
0x6a, 0x23, 0xed, 0x1f, 0x3d, 0x9b, 0xd5, 0xc4, 0xe8, 0x18, 0x78, 0x87, 0xab, 0x5f, 0x43, 0x39,
0x29, 0x2c, 0xb4, 0x39, 0x1d, 0x3d, 0x56, 0xaf, 0xf5, 0xd6, 0x3c, 0x90, 0x94, 0xfa, 0xb6, 0x1d,
0x51, 0x3c, 0x37, 0xf5, 0xdb, 0xa0, 0x5a, 0x98, 0x46, 0xfd, 0xf9, 0x91, 0xdf, 0x02, 0xa4, 0x75,
0x8b, 0x9e, 0xbf, 0x63, 0x95, 0xe7, 0x9a, 0xf7, 0x40, 0x8d, 0x8b, 0x0f, 0x3d, 0x9d, 0x25, 0xf9,
0x27, 0xca, 0xb4, 0xfe, 0x28, 0x0b, 0x4b, 0x3e, 0x0f, 0x8d, 0xf8, 0xf3, 0x90, 0x63, 0xac, 0xd8,
0x92, 0x00, 0x3d, 0x51, 0xd0, 0x31, 0x94, 0x78, 0xf7, 0x46, 0x8f, 0xa7, 0xdf, 0x96, 0xe9, 0xf2,
0xb9, 0xee, 0x53, 0x28, 0xf1, 0x81, 0x8d, 0x66, 0xa8, 0xa4, 0xc9, 0x4f, 0x8f, 0xfa, 0xd3, 0x39,
0x51, 0x32, 0x0b, 0xbe, 0x86, 0xca, 0xcd, 0xf0, 0x47, 0x33, 0xa4, 0xd1, 0xf8, 0x97, 0x42, 0xee,
0x6b, 0x4e, 0x60, 0x51, 0xce, 0x23, 0x34, 0x43, 0x39, 0x8c, 0x8e, 0xae, 0x5c, 0xa3, 0x5f, 0x41,
0x39, 0xe9, 0xc6, 0xb9, 0xc9, 0x37, 0xc3, 0x23, 0x26, 0x3a, 0xfa, 0x2b, 0x50, 0xe3, 0xfe, 0x3c,
0x4b, 0xef, 0x9b, 0xe8, 0xe4, 0x79, 0xee, 0xee, 0x1d, 0x5f, 0xbd, 0x6d, 0xdc, 0xf9, 0xeb, 0x6d,
0xe3, 0xce, 0x8f, 0xd7, 0x0d, 0xe5, 0xea, 0xba, 0xa1, 0xfc, 0x79, 0xdd, 0x50, 0xfe, 0xb9, 0x6e,
0x28, 0xdf, 0x6c, 0xcd, 0xf7, 0x1f, 0xde, 0x67, 0xfc, 0xf7, 0x4c, 0x15, 0xe6, 0xb7, 0xfe, 0x0d,
0x00, 0x00, 0xff, 0xff, 0xf6, 0xcc, 0xc3, 0x0f, 0x1f, 0x0e, 0x00, 0x00,
// 1114 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0x4f, 0x6f, 0xe3, 0x44,
0x14, 0xaf, 0x93, 0xd4, 0x4d, 0x5e, 0x94, 0xd2, 0xce, 0x76, 0x8b, 0x37, 0x8b, 0xd2, 0xc8, 0x87,
0x25, 0x68, 0xb5, 0xf6, 0x36, 0x65, 0xff, 0xb0, 0x9c, 0xda, 0x6e, 0x85, 0x2a, 0xa8, 0x88, 0xdc,
0x5d, 0x90, 0x40, 0xa8, 0x72, 0xe3, 0x69, 0x32, 0x6a, 0xe2, 0xf1, 0x7a, 0xc6, 0xa5, 0xe5, 0xc4,
0x89, 0x33, 0x1f, 0x81, 0x03, 0x37, 0xbe, 0x48, 0x8f, 0x1c, 0x39, 0x2d, 0x6c, 0xee, 0x7c, 0x07,
0x34, 0xe3, 0x71, 0xed, 0x24, 0x35, 0x49, 0x10, 0x97, 0x66, 0xde, 0xcc, 0xfb, 0xcd, 0xfc, 0xde,
0x7f, 0x17, 0x3e, 0xe9, 0x11, 0xde, 0x8f, 0x4e, 0xad, 0x2e, 0x1d, 0xda, 0x5d, 0xea, 0x73, 0x97,
0xf8, 0x38, 0xf4, 0xb2, 0xcb, 0x01, 0xf1, 0xa3, 0x4b, 0x9b, 0xf5, 0xc9, 0xd0, 0xbe, 0xd8, 0x96,
0xbf, 0x56, 0x10, 0x52, 0x4e, 0x51, 0x33, 0x55, 0xb2, 0xc2, 0xc8, 0xe7, 0x64, 0x88, 0x2d, 0xa9,
0x6c, 0x49, 0xa5, 0x8b, 0xed, 0xfa, 0xbd, 0x1e, 0xa5, 0xbd, 0x01, 0xb6, 0xa5, 0xfe, 0x69, 0x74,
0x66, 0xbb, 0xfe, 0x55, 0x0c, 0xae, 0xdf, 0x9f, 0x3c, 0xc2, 0xc3, 0x80, 0x27, 0x87, 0x1b, 0x3d,
0xda, 0xa3, 0x72, 0x69, 0x8b, 0x95, 0xda, 0xdd, 0x9a, 0x84, 0x88, 0x17, 0x19, 0x77, 0x87, 0x81,
0x52, 0x78, 0x3a, 0xd3, 0x16, 0x37, 0x20, 0x36, 0xbf, 0x0a, 0x30, 0xb3, 0x87, 0x34, 0xf2, 0xb9,
0xc2, 0xbd, 0x58, 0x00, 0xc7, 0x5d, 0x76, 0x2e, 0xff, 0x28, 0xec, 0xc1, 0x5c, 0x58, 0x86, 0xc3,
0x0b, 0xd2, 0xc5, 0xcc, 0xc6, 0x17, 0xd8, 0xe7, 0x4c, 0x38, 0x32, 0xf1, 0x98, 0xbc, 0xc6, 0xfc,
0xbb, 0x00, 0xeb, 0xfb, 0x21, 0x76, 0x39, 0x7e, 0xe5, 0xb2, 0x73, 0x07, 0xbf, 0x89, 0x30, 0xe3,
0x68, 0x13, 0x0a, 0xc4, 0x33, 0xb4, 0xa6, 0xd6, 0xaa, 0xec, 0xe9, 0xa3, 0xb7, 0x5b, 0x85, 0xc3,
0x97, 0x4e, 0x81, 0x78, 0x68, 0x13, 0xf4, 0xd3, 0xc8, 0xf7, 0x06, 0xd8, 0x28, 0x88, 0x33, 0x47,
0x49, 0xc8, 0x80, 0x15, 0x75, 0xad, 0x51, 0x94, 0x07, 0x89, 0x88, 0x6c, 0xd0, 0x43, 0x4a, 0xf9,
0x19, 0x33, 0x4a, 0xcd, 0x62, 0xab, 0xda, 0x7e, 0xdf, 0xca, 0x04, 0x4f, 0x5a, 0x66, 0x1d, 0x09,
0x8f, 0x38, 0x4a, 0x0d, 0xd5, 0xa1, 0xcc, 0x71, 0x38, 0x24, 0xbe, 0x3b, 0x30, 0x96, 0x9b, 0x5a,
0xab, 0xec, 0xdc, 0xc8, 0x68, 0x03, 0x96, 0x19, 0xf7, 0x88, 0x6f, 0xe8, 0xf2, 0x91, 0x58, 0x10,
0xa4, 0x18, 0xf7, 0x68, 0xc4, 0x8d, 0x95, 0x98, 0x54, 0x2c, 0xa9, 0x7d, 0x1c, 0x86, 0x46, 0xf9,
0x66, 0x1f, 0x87, 0x21, 0x6a, 0x00, 0x74, 0xfb, 0xb8, 0x7b, 0x1e, 0x50, 0xe2, 0x73, 0xa3, 0x22,
0xcf, 0x32, 0x3b, 0xe8, 0x21, 0xac, 0x07, 0x6e, 0x88, 0x7d, 0x7e, 0x92, 0x51, 0x03, 0xa9, 0xb6,
0x16, 0x1f, 0xec, 0xa7, 0xca, 0x16, 0xac, 0xd0, 0x80, 0x13, 0xea, 0x33, 0xa3, 0xda, 0xd4, 0x5a,
0xd5, 0xf6, 0x86, 0x15, 0x67, 0x8b, 0x95, 0x64, 0x8b, 0xb5, 0xeb, 0x5f, 0x39, 0x89, 0x92, 0xf9,
0x00, 0x50, 0xd6, 0xdd, 0x2c, 0xa0, 0x3e, 0xc3, 0x68, 0x0d, 0x8a, 0x81, 0x72, 0x78, 0xcd, 0x11,
0x4b, 0xf3, 0x27, 0x0d, 0x56, 0x5f, 0xe2, 0x01, 0xe6, 0x38, 0x5f, 0x09, 0x6d, 0x41, 0x15, 0x5f,
0x12, 0x7e, 0xc2, 0xb8, 0xcb, 0x23, 0x26, 0x63, 0x52, 0x73, 0x40, 0x6c, 0x1d, 0xcb, 0x1d, 0xb4,
0x0b, 0x15, 0x21, 0x61, 0xef, 0xc4, 0xe5, 0x32, 0x32, 0xd5, 0x76, 0x7d, 0x8a, 0xdf, 0xab, 0x24,
0x9b, 0xf7, 0xca, 0xd7, 0x6f, 0xb7, 0x96, 0x7e, 0xfe, 0x73, 0x4b, 0x73, 0xca, 0x31, 0x6c, 0x97,
0x9b, 0x2d, 0xd8, 0x88, 0x79, 0x74, 0x42, 0xda, 0xc5, 0x8c, 0x25, 0x29, 0x32, 0x4d, 0xf9, 0x17,
0x0d, 0xd0, 0xc1, 0x25, 0xee, 0x4e, 0x28, 0x66, 0x03, 0xaa, 0xe5, 0x05, 0xb4, 0x70, 0x7b, 0x40,
0x8b, 0x39, 0x01, 0x2d, 0x8d, 0x05, 0xb4, 0x05, 0x25, 0x16, 0xe0, 0xae, 0x4c, 0x97, 0xbc, 0x00,
0x48, 0x0d, 0xf3, 0x43, 0xb8, 0x33, 0xc6, 0x30, 0xd7, 0xfd, 0x0e, 0xac, 0x39, 0x98, 0x91, 0x1f,
0x70, 0x87, 0x5f, 0xe5, 0x5a, 0x2c, 0xe8, 0x7f, 0x4f, 0x3c, 0xde, 0x57, 0x9e, 0x8f, 0x05, 0x41,
0xb3, 0x8f, 0x49, 0xaf, 0x1f, 0xd3, 0xaf, 0x39, 0x4a, 0x32, 0x7f, 0x2d, 0x40, 0x4d, 0xc4, 0x25,
0x8d, 0xe8, 0xa2, 0x65, 0xa6, 0x18, 0x14, 0x53, 0x06, 0x3b, 0xc2, 0x25, 0x32, 0xf8, 0xc2, 0x25,
0xab, 0xed, 0xfb, 0xd9, 0xf2, 0xba, 0xd8, 0x56, 0x15, 0x16, 0x67, 0x83, 0xa3, 0x54, 0xd1, 0x0b,
0xa8, 0x04, 0xb1, 0x07, 0x30, 0x33, 0x96, 0x65, 0x59, 0x7e, 0x70, 0x2b, 0x2e, 0xf1, 0x53, 0xaa,
0xfe, 0x3f, 0x95, 0x60, 0x36, 0x27, 0x2a, 0xe3, 0x39, 0x61, 0x1e, 0x42, 0xf5, 0x73, 0x32, 0x18,
0xa4, 0xad, 0x48, 0x67, 0xa4, 0x97, 0x24, 0x4f, 0xcd, 0x51, 0x92, 0xf0, 0x85, 0x3b, 0x18, 0x48,
0x07, 0x95, 0x1d, 0xb1, 0x9c, 0xf6, 0x8e, 0xf9, 0x1c, 0x56, 0xf7, 0x07, 0x94, 0xe1, 0xc3, 0x2f,
0xff, 0x35, 0x86, 0x69, 0x0a, 0x96, 0x95, 0x41, 0xe6, 0x47, 0xf0, 0xde, 0x17, 0x84, 0xf1, 0x0e,
0xf1, 0xd8, 0x8c, 0x9e, 0x68, 0x3e, 0x80, 0xb5, 0x54, 0x55, 0x05, 0x16, 0x41, 0x29, 0x20, 0x1e,
0x33, 0xb4, 0x66, 0xb1, 0x55, 0x73, 0xe4, 0xda, 0xfc, 0x16, 0xee, 0xa6, 0x7d, 0x23, 0xdb, 0x6c,
0x85, 0xb2, 0xcb, 0xfb, 0xf1, 0xd5, 0x8e, 0x5c, 0x67, 0xdb, 0x4a, 0x61, 0x9e, 0xb6, 0xf2, 0x08,
0xd6, 0x8e, 0xfb, 0x64, 0x78, 0xe8, 0x9f, 0xd1, 0x1b, 0x12, 0xf7, 0xa0, 0x2c, 0xe6, 0xe1, 0x49,
0x6a, 0xf0, 0x8a, 0x90, 0x3b, 0xc4, 0x33, 0xef, 0xc2, 0x9d, 0x63, 0x1e, 0x62, 0x77, 0x78, 0x20,
0xc7, 0x82, 0x62, 0x62, 0x7e, 0x06, 0xeb, 0xaf, 0x03, 0x6f, 0x62, 0x16, 0xb4, 0xa1, 0x12, 0x62,
0x46, 0xa3, 0xb0, 0x8b, 0x99, 0xbc, 0x27, 0x8f, 0x4c, 0xaa, 0xd6, 0xfe, 0xad, 0x0a, 0x25, 0xc1,
0x07, 0x75, 0x60, 0x59, 0xa6, 0x3c, 0xda, 0x9c, 0x82, 0x1c, 0x88, 0xb9, 0x5b, 0xb7, 0xad, 0x59,
0xc3, 0xdc, 0x1a, 0xaf, 0x19, 0x06, 0x7a, 0xdc, 0x40, 0xd1, 0xce, 0x6c, 0xe8, 0xd4, 0x64, 0xab,
0x7f, 0xbc, 0x18, 0x48, 0x3d, 0xfa, 0x4c, 0x9a, 0x11, 0xf2, 0x5c, 0x33, 0x72, 0xf6, 0x91, 0x03,
0x7a, 0xdc, 0x3d, 0x73, 0x91, 0x8f, 0x67, 0x13, 0x9a, 0x98, 0x03, 0x57, 0x50, 0x1b, 0xeb, 0xc8,
0xe8, 0xe9, 0xbc, 0x57, 0x8c, 0x77, 0xe6, 0xff, 0xf0, 0xf4, 0x1b, 0x28, 0x27, 0xb9, 0x8e, 0xb6,
0x67, 0xa3, 0x27, 0x4a, 0xa8, 0xde, 0x5e, 0x04, 0x92, 0xba, 0xbe, 0xe3, 0x46, 0x0c, 0x2f, 0xec,
0xfa, 0xe7, 0xa0, 0x3b, 0x98, 0x45, 0xc3, 0xc5, 0x91, 0xdf, 0x01, 0x64, 0x26, 0xfc, 0xb3, 0x39,
0x32, 0xe6, 0xb6, 0xba, 0xce, 0xbd, 0xde, 0x07, 0x3d, 0x2e, 0x3e, 0xf4, 0x64, 0x9e, 0xe4, 0x9f,
0x2a, 0xd3, 0xfa, 0xc3, 0x2c, 0x2c, 0xf9, 0xc2, 0xb3, 0xe2, 0x2f, 0x3c, 0x81, 0x71, 0xe2, 0x9b,
0x24, 0xe8, 0xb1, 0x86, 0x8e, 0xa0, 0x24, 0x1a, 0x2a, 0x7a, 0x34, 0xfb, 0xb5, 0x4c, 0xe3, 0xcd,
0xa5, 0xcf, 0xa0, 0x24, 0x66, 0x28, 0x9a, 0xa3, 0x92, 0xa6, 0xbf, 0x06, 0xea, 0x4f, 0x16, 0x44,
0xa9, 0x2c, 0xf8, 0x1a, 0x2a, 0x37, 0xf3, 0x18, 0xcd, 0x91, 0x46, 0x93, 0xc3, 0x3b, 0xd7, 0x9a,
0x63, 0x58, 0x51, 0x23, 0x02, 0xcd, 0x51, 0x0e, 0xe3, 0xd3, 0x24, 0xf7, 0xd2, 0xaf, 0xa0, 0x9c,
0x74, 0xe3, 0xdc, 0xe4, 0x9b, 0xc3, 0x88, 0xa9, 0x8e, 0xfe, 0x1a, 0xf4, 0xb8, 0x3f, 0xcf, 0xd3,
0xfb, 0xa6, 0x3a, 0x79, 0x1e, 0xdd, 0xbd, 0xa3, 0xeb, 0x77, 0x8d, 0xa5, 0x3f, 0xde, 0x35, 0x96,
0x7e, 0x1c, 0x35, 0xb4, 0xeb, 0x51, 0x43, 0xfb, 0x7d, 0xd4, 0xd0, 0xfe, 0x1a, 0x35, 0xb4, 0x6f,
0x76, 0x16, 0xfb, 0x27, 0xed, 0x53, 0xf1, 0x7b, 0xaa, 0xcb, 0xeb, 0x77, 0xfe, 0x09, 0x00, 0x00,
0xff, 0xff, 0xe2, 0x51, 0xa8, 0x39, 0xe2, 0x0d, 0x00, 0x00,
}

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

@ -63,6 +63,7 @@ message CreateTaskRequest {
string stderr = 8;
string checkpoint = 9;
string parent_checkpoint = 10;
google.protobuf.Any options = 11;
}
message CreateTaskResponse {
@ -130,7 +131,7 @@ message ListPidsResponse{
message CheckpointTaskRequest {
string path = 1;
map<string, string> options = 2;
google.protobuf.Any options = 2;
}
message ShimInfoResponse {

6
linux/task.go
View File

@ -160,10 +160,12 @@ func (t *Task) CloseIO(ctx context.Context, pid uint32) error {
return err
}
func (t *Task) Checkpoint(ctx context.Context, path string, options map[string]string) error {
func (t *Task) Checkpoint(ctx context.Context, path string, options []byte) error {
r := &shim.CheckpointTaskRequest{
Path: path,
Options: options,
Options: &protobuf.Any{
Value: options,
},
}
if _, err := t.shim.Checkpoint(ctx, r); err != nil {
return errors.New(grpc.ErrorDesc(err))

3
runtime/runtime.go
View File

@ -21,7 +21,10 @@ type CreateOpts struct {
Rootfs []mount.Mount
// IO for the container's main process
IO IO
// Checkpoint digest to restore container state
Checkpoint string
// Options for the runtime and container
Options []byte
}
type Exit struct {

2
runtime/task.go
View File

@ -32,7 +32,7 @@ type Task interface {
// CloseStdin closes the processes stdin
CloseIO(context.Context, uint32) error
// Checkpoint checkpoints a container to an image with live system data
Checkpoint(context.Context, string, map[string]string) error
Checkpoint(context.Context, string, []byte) 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

12
services/tasks/service.go
View File

@ -121,7 +121,10 @@ func (s *Service) Create(ctx context.Context, r *api.CreateTaskRequest) (*api.Cr
if err != nil {
return nil, errdefs.ToGRPC(err)
}
var options []byte
if r.Options != nil {
options = r.Options.Value
}
opts := runtime.CreateOpts{
Spec: container.Spec,
IO: runtime.IO{
@ -131,6 +134,7 @@ func (s *Service) Create(ctx context.Context, r *api.CreateTaskRequest) (*api.Cr
Terminal: r.Terminal,
},
Checkpoint: checkpointPath,
Options: options,
}
for _, m := range r.Rootfs {
opts.Rootfs = append(opts.Rootfs, mount.Mount{
@ -414,7 +418,11 @@ func (s *Service) Checkpoint(ctx context.Context, r *api.CheckpointTaskRequest)
return nil, err
}
defer os.RemoveAll(image)
if err := t.Checkpoint(ctx, image, r.Options); err != nil {
var options []byte
if r.Options != nil {
options = r.Options.Value
}
if err := t.Checkpoint(ctx, image, options); err != nil {
return nil, err
}
// write checkpoint to the content store

6
task.go
View File

@ -248,15 +248,9 @@ func (t *task) Resize(ctx context.Context, w, h uint32) error {
return err
}
func WithExit(r *tasks.CheckpointTaskRequest) error {
r.Options["exit"] = "true"
return nil
}
func (t *task) Checkpoint(ctx context.Context, opts ...CheckpointOpts) (d v1.Descriptor, err error) {
request := &tasks.CheckpointTaskRequest{
ContainerID: t.containerID,
Options: make(map[string]string),
}
for _, o := range opts {
if err := o(request); err != nil {

2
windows/container.go
View File

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