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

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

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

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

108
checkpoint_test.go
View File

@ -1,8 +1,14 @@
package containerd package containerd
import ( import (
"path/filepath"
"syscall" "syscall"
"testing" "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) { func TestCheckpointRestore(t *testing.T) {
@ -200,3 +206,105 @@ func TestCheckpointRestoreNewContainer(t *testing.T) {
} }
<-statusC <-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
}

7
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 { return func(ctx context.Context, client *Client, c *containers.Container) error {
c.Runtime = &containers.Container_Runtime{ c.Runtime = &containers.Container_Runtime{
Name: name, Name: name,
Options: options,
} }
return nil return nil
} }

29
cmd/ctr/checkpoint.go
View File

@ -2,8 +2,13 @@ package main
import ( import (
"fmt" "fmt"
"path/filepath"
"github.com/containerd/containerd" "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/pkg/errors"
"github.com/urfave/cli" "github.com/urfave/cli"
) )
@ -42,7 +47,7 @@ var checkpointCommand = cli.Command{
} }
var opts []containerd.CheckpointOpts var opts []containerd.CheckpointOpts
if context.Bool("exit") { if context.Bool("exit") {
opts = append(opts, containerd.WithExit) opts = append(opts, WithExit)
} }
checkpoint, err := task.Checkpoint(ctx, opts...) checkpoint, err := task.Checkpoint(ctx, opts...)
if err != nil { if err != nil {
@ -52,3 +57,25 @@ var checkpointCommand = cli.Command{
return nil 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/plugin"
"github.com/containerd/containerd/runtime" "github.com/containerd/containerd/runtime"
runc "github.com/containerd/go-runc" runc "github.com/containerd/go-runc"
protobuf "github.com/gogo/protobuf/types"
google_protobuf "github.com/golang/protobuf/ptypes/empty" google_protobuf "github.com/golang/protobuf/ptypes/empty"
"github.com/pkg/errors" "github.com/pkg/errors"
@ -171,6 +172,9 @@ func (r *Runtime) Create(ctx context.Context, id string, opts runtime.CreateOpts
Stderr: opts.IO.Stderr, Stderr: opts.IO.Stderr,
Terminal: opts.IO.Terminal, Terminal: opts.IO.Terminal,
Checkpoint: opts.Checkpoint, Checkpoint: opts.Checkpoint,
Options: &protobuf.Any{
Value: opts.Options,
},
} }
for _, m := range opts.Rootfs { for _, m := range opts.Rootfs {
sopts.Rootfs = append(sopts.Rootfs, &types.Mount{ sopts.Rootfs = append(sopts.Rootfs, &types.Mount{

53
linux/shim/init.go
View File

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

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

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

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

8
linux/task.go
View File

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

5
runtime/runtime.go
View File

@ -20,8 +20,11 @@ type CreateOpts struct {
// Rootfs mounts to perform to gain access to the container's filesystem // Rootfs mounts to perform to gain access to the container's filesystem
Rootfs []mount.Mount Rootfs []mount.Mount
// IO for the container's main process // IO for the container's main process
IO IO IO IO
// Checkpoint digest to restore container state
Checkpoint string Checkpoint string
// Options for the runtime and container
Options []byte
} }
type Exit struct { type Exit struct {

2
runtime/task.go
View File

@ -32,7 +32,7 @@ type Task interface {
// CloseStdin closes the processes stdin // CloseStdin closes the processes stdin
CloseIO(context.Context, uint32) error CloseIO(context.Context, uint32) error
// Checkpoint checkpoints a container to an image with live system data // 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 deletes a specific exec process via the pid
DeleteProcess(context.Context, uint32) (*Exit, error) DeleteProcess(context.Context, uint32) (*Exit, error)
// Update sets the provided resources to a running task // 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 { if err != nil {
return nil, errdefs.ToGRPC(err) return nil, errdefs.ToGRPC(err)
} }
var options []byte
if r.Options != nil {
options = r.Options.Value
}
opts := runtime.CreateOpts{ opts := runtime.CreateOpts{
Spec: container.Spec, Spec: container.Spec,
IO: runtime.IO{ IO: runtime.IO{
@ -131,6 +134,7 @@ func (s *Service) Create(ctx context.Context, r *api.CreateTaskRequest) (*api.Cr
Terminal: r.Terminal, Terminal: r.Terminal,
}, },
Checkpoint: checkpointPath, Checkpoint: checkpointPath,
Options: options,
} }
for _, m := range r.Rootfs { for _, m := range r.Rootfs {
opts.Rootfs = append(opts.Rootfs, mount.Mount{ opts.Rootfs = append(opts.Rootfs, mount.Mount{
@ -414,7 +418,11 @@ func (s *Service) Checkpoint(ctx context.Context, r *api.CheckpointTaskRequest)
return nil, err return nil, err
} }
defer os.RemoveAll(image) 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 return nil, err
} }
// write checkpoint to the content store // 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 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) { func (t *task) Checkpoint(ctx context.Context, opts ...CheckpointOpts) (d v1.Descriptor, err error) {
request := &tasks.CheckpointTaskRequest{ request := &tasks.CheckpointTaskRequest{
ContainerID: t.containerID, ContainerID: t.containerID,
Options: make(map[string]string),
} }
for _, o := range opts { for _, o := range opts {
if err := o(request); err != nil { 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 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") return fmt.Errorf("Windows containers do not support checkpoint")
} }