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

Merge pull request #1098 from crosbymichael/ropts

Browse Source 
Implement options for runtime specific settings
This commit is contained in:
Kenfe-Mickaël Laventure 2017-06-30 08:46:29 -07:00 committed by GitHub
commit e7ba3fb600
26 changed files with 1829 additions and 830 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

257
api/services/containers/v1/containers.pb.go
View File

@ -101,7 +101,7 @@ type Container_Runtime struct {
// Name is the name of the runtime.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// Options specify additional runtime initialization options.
Options map[string]string `protobuf:"bytes,2,rep,name=options" json:"options,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
Options *google_protobuf1.Any `protobuf:"bytes,2,opt,name=options" json:"options,omitempty"`
}
func (m *Container_Runtime) Reset() { *m = Container_Runtime{} }
@ -523,22 +523,15 @@ func (m *Container_Runtime) MarshalTo(dAtA []byte) (int, error) {
i = encodeVarintContainers(dAtA, i, uint64(len(m.Name)))
i += copy(dAtA[i:], m.Name)
}
if len(m.Options) > 0 {
for k, _ := range m.Options {
dAtA[i] = 0x12
i++
v := m.Options[k]
mapSize := 1 + len(k) + sovContainers(uint64(len(k))) + 1 + len(v) + sovContainers(uint64(len(v)))
i = encodeVarintContainers(dAtA, i, uint64(mapSize))
dAtA[i] = 0xa
i++
i = encodeVarintContainers(dAtA, i, uint64(len(k)))
i += copy(dAtA[i:], k)
dAtA[i] = 0x12
i++
i = encodeVarintContainers(dAtA, i, uint64(len(v)))
i += copy(dAtA[i:], v)
if m.Options != nil {
dAtA[i] = 0x12
i++
i = encodeVarintContainers(dAtA, i, uint64(m.Options.Size()))
n5, err := m.Options.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n5
}
return i, nil
}
@ -585,11 +578,11 @@ func (m *GetContainerResponse) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0xa
i++
i = encodeVarintContainers(dAtA, i, uint64(m.Container.Size()))
n5, err := m.Container.MarshalTo(dAtA[i:])
n6, err := m.Container.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n5
i += n6
return i, nil
}
@ -665,11 +658,11 @@ func (m *CreateContainerRequest) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0xa
i++
i = encodeVarintContainers(dAtA, i, uint64(m.Container.Size()))
n6, err := m.Container.MarshalTo(dAtA[i:])
n7, err := m.Container.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n6
i += n7
return i, nil
}
@ -691,11 +684,11 @@ func (m *CreateContainerResponse) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0xa
i++
i = encodeVarintContainers(dAtA, i, uint64(m.Container.Size()))
n7, err := m.Container.MarshalTo(dAtA[i:])
n8, err := m.Container.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n7
i += n8
return i, nil
}
@ -717,20 +710,20 @@ func (m *UpdateContainerRequest) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0xa
i++
i = encodeVarintContainers(dAtA, i, uint64(m.Container.Size()))
n8, err := m.Container.MarshalTo(dAtA[i:])
n9, err := m.Container.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n8
i += n9
if m.UpdateMask != nil {
dAtA[i] = 0x12
i++
i = encodeVarintContainers(dAtA, i, uint64(m.UpdateMask.Size()))
n9, err := m.UpdateMask.MarshalTo(dAtA[i:])
n10, err := m.UpdateMask.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n9
i += n10
}
return i, nil
}
@ -753,11 +746,11 @@ func (m *UpdateContainerResponse) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0xa
i++
i = encodeVarintContainers(dAtA, i, uint64(m.Container.Size()))
n10, err := m.Container.MarshalTo(dAtA[i:])
n11, err := m.Container.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n10
i += n11
return i, nil
}
@ -857,13 +850,9 @@ func (m *Container_Runtime) Size() (n int) {
if l > 0 {
n += 1 + l + sovContainers(uint64(l))
}
if len(m.Options) > 0 {
for k, v := range m.Options {
_ = k
_ = v
mapEntrySize := 1 + len(k) + sovContainers(uint64(len(k))) + 1 + len(v) + sovContainers(uint64(len(v)))
n += mapEntrySize + 1 + sovContainers(uint64(mapEntrySize))
}
if m.Options != nil {
l = m.Options.Size()
n += 1 + l + sovContainers(uint64(l))
}
return n
}
@ -998,19 +987,9 @@ func (this *Container_Runtime) String() string {
if this == nil {
return "nil"
}
keysForOptions := make([]string, 0, len(this.Options))
for k, _ := range this.Options {
keysForOptions = append(keysForOptions, k)
}
github_com_gogo_protobuf_sortkeys.Strings(keysForOptions)
mapStringForOptions := "map[string]string{"
for _, k := range keysForOptions {
mapStringForOptions += fmt.Sprintf("%v: %v,", k, this.Options[k])
}
mapStringForOptions += "}"
s := strings.Join([]string{`&Container_Runtime{`,
`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
`Options:` + mapStringForOptions + `,`,
`Options:` + strings.Replace(fmt.Sprintf("%v", this.Options), "Any", "google_protobuf1.Any", 1) + `,`,
`}`,
}, "")
return s
@ -1577,94 +1556,11 @@ func (m *Container_Runtime) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
var keykey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowContainers
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
keykey |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
var stringLenmapkey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowContainers
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLenmapkey |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLenmapkey := int(stringLenmapkey)
if intStringLenmapkey < 0 {
return ErrInvalidLengthContainers
}
postStringIndexmapkey := iNdEx + intStringLenmapkey
if postStringIndexmapkey > l {
return io.ErrUnexpectedEOF
}
mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
iNdEx = postStringIndexmapkey
if m.Options == nil {
m.Options = make(map[string]string)
m.Options = &google_protobuf1.Any{}
}
if iNdEx < postIndex {
var valuekey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowContainers
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
valuekey |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
var stringLenmapvalue uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowContainers
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLenmapvalue |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLenmapvalue := int(stringLenmapvalue)
if intStringLenmapvalue < 0 {
return ErrInvalidLengthContainers
}
postStringIndexmapvalue := iNdEx + intStringLenmapvalue
if postStringIndexmapvalue > l {
return io.ErrUnexpectedEOF
}
mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
iNdEx = postStringIndexmapvalue
m.Options[mapkey] = mapvalue
} else {
var mapvalue string
m.Options[mapkey] = mapvalue
if err := m.Options.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
@ -2549,53 +2445,52 @@ func init() {
}
var fileDescriptorContainers = []byte{
// 756 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0xcd, 0x72, 0x12, 0x4b,
0x14, 0xce, 0x00, 0x19, 0xc2, 0xe1, 0x2e, 0x6e, 0xf5, 0xe5, 0x72, 0xe7, 0x8e, 0x55, 0x80, 0xac,
0x58, 0xe8, 0x8c, 0x41, 0x4b, 0xf3, 0xb3, 0x82, 0xfc, 0x95, 0x55, 0x51, 0x53, 0xad, 0x6e, 0xcc,
0x22, 0x0e, 0xd0, 0x90, 0x91, 0x61, 0x7a, 0x9c, 0x6e, 0xa8, 0xa2, 0x5c, 0xe8, 0x23, 0xf8, 0x16,
0x79, 0x03, 0x9f, 0x21, 0x4b, 0x97, 0xae, 0x62, 0xc2, 0x93, 0x58, 0xd3, 0xd3, 0x93, 0x41, 0x20,
0x25, 0xa0, 0xd9, 0xf5, 0xe1, 0x9c, 0xef, 0x3b, 0xa7, 0xbf, 0x73, 0xce, 0xd0, 0x70, 0xd8, 0xb1,
0xf9, 0x69, 0xbf, 0x61, 0x34, 0x69, 0xcf, 0x6c, 0x52, 0x97, 0x5b, 0xb6, 0x4b, 0xfc, 0xd6, 0xf8,
0xd1, 0xf2, 0x6c, 0x93, 0x11, 0x7f, 0x60, 0x37, 0x09, 0x8b, 0x7f, 0x67, 0xe6, 0x60, 0x7d, 0xcc,
0x32, 0x3c, 0x9f, 0x72, 0x8a, 0xee, 0xc6, 0x38, 0x23, 0xc2, 0x18, 0x63, 0x51, 0x83, 0x75, 0x3d,
0xd7, 0xa1, 0x1d, 0x2a, 0xa2, 0xcd, 0xe0, 0x14, 0x02, 0xf5, 0xff, 0x3b, 0x94, 0x76, 0x1c, 0x62,
0x0a, 0xab, 0xd1, 0x6f, 0x9b, 0x96, 0x3b, 0x94, 0xae, 0x3b, 0x93, 0x2e, 0xd2, 0xf3, 0x78, 0xe4,
0x2c, 0x4d, 0x3a, 0xdb, 0x36, 0x71, 0x5a, 0x27, 0x3d, 0x8b, 0x75, 0x65, 0x44, 0x71, 0x32, 0x82,
0xdb, 0x3d, 0xc2, 0xb8, 0xd5, 0xf3, 0x64, 0xc0, 0xf6, 0x5c, 0x0a, 0xf0, 0xa1, 0x47, 0x98, 0xd9,
0x22, 0xac, 0xe9, 0xdb, 0x1e, 0xa7, 0x7e, 0x08, 0x2e, 0x9f, 0xad, 0x42, 0x66, 0x27, 0x8a, 0x44,
0x79, 0x48, 0xd8, 0x2d, 0x4d, 0x29, 0x29, 0x95, 0x4c, 0x5d, 0x1d, 0x5d, 0x14, 0x13, 0x4f, 0x77,
0x71, 0xc2, 0x6e, 0xa1, 0x23, 0x50, 0x1d, 0xab, 0x41, 0x1c, 0xa6, 0x25, 0x4a, 0xc9, 0x4a, 0xb6,
0xba, 0x61, 0xfc, 0x52, 0x27, 0xe3, 0x9a, 0xd5, 0x38, 0x14, 0xd0, 0x3d, 0x97, 0xfb, 0x43, 0x2c,
0x79, 0x50, 0x0e, 0x56, 0xed, 0x9e, 0xd5, 0x21, 0x5a, 0x32, 0x48, 0x86, 0x43, 0x03, 0x3d, 0x87,
0xb4, 0xdf, 0x77, 0x83, 0x0b, 0x6a, 0xa9, 0x92, 0x52, 0xc9, 0x56, 0x1f, 0x2d, 0x94, 0x08, 0x87,
0x58, 0x1c, 0x91, 0xa0, 0x0a, 0xa4, 0x98, 0x47, 0x9a, 0xda, 0xaa, 0x20, 0xcb, 0x19, 0xa1, 0x94,
0x46, 0x24, 0xa5, 0x51, 0x73, 0x87, 0x58, 0x44, 0xa0, 0x32, 0xa8, 0x3e, 0xa5, 0xbc, 0xcd, 0x34,
0x55, 0xdc, 0x1e, 0x46, 0x17, 0x45, 0x15, 0x53, 0xca, 0xf7, 0x5f, 0x62, 0xe9, 0x41, 0x3b, 0x00,
0x4d, 0x9f, 0x58, 0x9c, 0xb4, 0x4e, 0x2c, 0xae, 0xa5, 0x05, 0xa7, 0x3e, 0xc5, 0xf9, 0x2a, 0x6a,
0x4f, 0x7d, 0xed, 0xfc, 0xa2, 0xb8, 0xf2, 0xf9, 0x7b, 0x51, 0xc1, 0x19, 0x89, 0xab, 0xf1, 0x80,
0xa4, 0xef, 0xb5, 0x22, 0x92, 0xb5, 0x45, 0x48, 0x24, 0xae, 0xc6, 0xf5, 0x4d, 0xc8, 0x8e, 0x89,
0x8a, 0xfe, 0x86, 0x64, 0x97, 0x0c, 0xc3, 0xbe, 0xe1, 0xe0, 0x18, 0xc8, 0x3b, 0xb0, 0x9c, 0x3e,
0xd1, 0x12, 0xa1, 0xbc, 0xc2, 0xd8, 0x4a, 0x6c, 0x28, 0xfa, 0x17, 0x05, 0xd2, 0x52, 0x27, 0x84,
0x20, 0xe5, 0x5a, 0x3d, 0x22, 0x81, 0xe2, 0x8c, 0x8e, 0x21, 0x4d, 0x3d, 0x6e, 0x53, 0x37, 0xea,
0x75, 0x6d, 0x99, 0x16, 0x18, 0x2f, 0x42, 0x8e, 0xb0, 0xe9, 0x11, 0xa3, 0xbe, 0x05, 0x7f, 0x8d,
0x3b, 0x16, 0x29, 0xbc, 0x7c, 0x1f, 0xfe, 0x39, 0x20, 0xfc, 0x3a, 0x13, 0x26, 0xef, 0xfb, 0x84,
0xf1, 0x9b, 0x46, 0xb6, 0x7c, 0x0a, 0xb9, 0x9f, 0xc3, 0x99, 0x47, 0x5d, 0x46, 0xd0, 0x11, 0x64,
0xae, 0x6b, 0x17, 0xb0, 0x6c, 0xf5, 0xde, 0x22, 0x37, 0xac, 0xa7, 0x82, 0x86, 0xe0, 0x98, 0xa4,
0x6c, 0xc2, 0xbf, 0x87, 0x36, 0x8b, 0x53, 0xb1, 0xb8, 0x34, 0xb5, 0x6d, 0x3b, 0x5c, 0xe6, 0xc9,
0x60, 0x69, 0x95, 0x1d, 0xc8, 0x4f, 0x02, 0x64, 0x71, 0x18, 0x20, 0x4e, 0xab, 0x29, 0x42, 0xff,
0x65, 0xaa, 0x1b, 0x63, 0x29, 0xbf, 0x83, 0xfc, 0x8e, 0x98, 0xbe, 0x29, 0xe9, 0xfe, 0xbc, 0x14,
0x5d, 0xf8, 0x6f, 0x2a, 0xd7, 0xad, 0xe9, 0x7e, 0xa6, 0x40, 0xfe, 0xb5, 0x58, 0x89, 0xdb, 0xbf,
0x19, 0xda, 0x86, 0x6c, 0xb8, 0x7e, 0xe2, 0xd3, 0x2c, 0xa6, 0x73, 0xd6, 0xde, 0xee, 0x07, 0x5f,
0xef, 0x67, 0x16, 0xeb, 0x62, 0xb9, 0xe5, 0xc1, 0x39, 0x90, 0x65, 0xaa, 0xd0, 0x5b, 0x93, 0xe5,
0x01, 0xe4, 0x77, 0x89, 0x43, 0x66, 0xa8, 0x72, 0xc3, 0xaa, 0x54, 0x2f, 0x53, 0x00, 0xf1, 0x30,
0xa2, 0x01, 0x24, 0x0f, 0x08, 0x47, 0x8f, 0xe7, 0x28, 0x63, 0xc6, 0x42, 0xea, 0x4f, 0x16, 0xc6,
0x49, 0x29, 0x3e, 0x40, 0x2a, 0x58, 0x0b, 0x34, 0xcf, 0x9f, 0xcb, 0xcc, 0x85, 0xd3, 0x37, 0x97,
0x40, 0xca, 0xe4, 0x1f, 0x41, 0x0d, 0x27, 0x17, 0xcd, 0x43, 0x32, 0x7b, 0xa1, 0xf4, 0xad, 0x65,
0xa0, 0x71, 0x01, 0xe1, 0x8c, 0xcc, 0x55, 0xc0, 0xec, 0xb9, 0x9f, 0xab, 0x80, 0x9b, 0x26, 0xf1,
0x18, 0xd4, 0x70, 0x6e, 0xe6, 0x2a, 0x60, 0xf6, 0x88, 0xe9, 0xf9, 0xa9, 0x8d, 0xd8, 0x0b, 0x1e,
0x3b, 0xf5, 0xb7, 0xe7, 0x57, 0x85, 0x95, 0x6f, 0x57, 0x85, 0x95, 0x4f, 0xa3, 0x82, 0x72, 0x3e,
0x2a, 0x28, 0x5f, 0x47, 0x05, 0xe5, 0x72, 0x54, 0x50, 0xde, 0xec, 0xff, 0xc6, 0xfb, 0x6d, 0x3b,
0xb6, 0x1a, 0xaa, 0xc8, 0xf8, 0xf0, 0x47, 0x00, 0x00, 0x00, 0xff, 0xff, 0x90, 0x4e, 0xa7, 0x59,
0x10, 0x0a, 0x00, 0x00,
// 738 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0xcd, 0x6e, 0xd3, 0x4a,
0x14, 0xae, 0x93, 0xd4, 0x69, 0x4e, 0x36, 0x57, 0x73, 0x73, 0x73, 0x8d, 0x91, 0x92, 0x90, 0x55,
0x16, 0x60, 0xd3, 0x80, 0xa0, 0x3f, 0xab, 0xa6, 0x7f, 0x42, 0x6a, 0x51, 0x35, 0xc0, 0x06, 0x16,
0xc5, 0x49, 0x26, 0xa9, 0x89, 0xe3, 0x31, 0x9e, 0x49, 0xa4, 0x88, 0x05, 0x3c, 0x02, 0x6f, 0xc1,
0x53, 0xb0, 0xef, 0x92, 0x25, 0xab, 0xd2, 0xe6, 0x49, 0x90, 0xc7, 0xe3, 0x3a, 0xe4, 0x47, 0x38,
0x85, 0xee, 0xe6, 0x78, 0xce, 0xf7, 0x9d, 0x33, 0xdf, 0x7c, 0x67, 0x64, 0x38, 0xea, 0xda, 0xfc,
0x6c, 0xd0, 0x34, 0x5a, 0xb4, 0x6f, 0xb6, 0xa8, 0xcb, 0x2d, 0xdb, 0x25, 0x7e, 0x7b, 0x72, 0x69,
0x79, 0xb6, 0xc9, 0x88, 0x3f, 0xb4, 0x5b, 0x84, 0xc5, 0xdf, 0x99, 0x39, 0x5c, 0x9f, 0x88, 0x0c,
0xcf, 0xa7, 0x9c, 0xa2, 0x7b, 0x31, 0xce, 0x88, 0x30, 0xc6, 0x44, 0xd6, 0x70, 0x5d, 0x2f, 0x74,
0x69, 0x97, 0x8a, 0x6c, 0x33, 0x58, 0x85, 0x40, 0xfd, 0x4e, 0x97, 0xd2, 0xae, 0x43, 0x4c, 0x11,
0x35, 0x07, 0x1d, 0xd3, 0x72, 0x47, 0x72, 0xeb, 0xee, 0xf4, 0x16, 0xe9, 0x7b, 0x3c, 0xda, 0xac,
0x4c, 0x6f, 0x76, 0x6c, 0xe2, 0xb4, 0x4f, 0xfb, 0x16, 0xeb, 0xc9, 0x8c, 0xf2, 0x74, 0x06, 0xb7,
0xfb, 0x84, 0x71, 0xab, 0xef, 0xc9, 0x84, 0xed, 0x44, 0x0a, 0xf0, 0x91, 0x47, 0x98, 0xd9, 0x26,
0xac, 0xe5, 0xdb, 0x1e, 0xa7, 0x7e, 0x08, 0xae, 0x7e, 0xcd, 0x40, 0x6e, 0x37, 0xca, 0x44, 0x45,
0x48, 0xd9, 0x6d, 0x4d, 0xa9, 0x28, 0xb5, 0x5c, 0x43, 0x1d, 0x5f, 0x94, 0x53, 0xcf, 0xf6, 0x70,
0xca, 0x6e, 0xa3, 0x13, 0x50, 0x1d, 0xab, 0x49, 0x1c, 0xa6, 0xa5, 0x2a, 0xe9, 0x5a, 0xbe, 0xbe,
0x61, 0xfc, 0x56, 0x27, 0xe3, 0x9a, 0xd5, 0x38, 0x12, 0xd0, 0x7d, 0x97, 0xfb, 0x23, 0x2c, 0x79,
0x50, 0x01, 0x56, 0xed, 0xbe, 0xd5, 0x25, 0x5a, 0x3a, 0x28, 0x86, 0xc3, 0x00, 0x3d, 0x87, 0xac,
0x3f, 0x70, 0x83, 0x03, 0x6a, 0x99, 0x8a, 0x52, 0xcb, 0xd7, 0x1f, 0x2f, 0x55, 0x08, 0x87, 0x58,
0x1c, 0x91, 0xa0, 0x1a, 0x64, 0x98, 0x47, 0x5a, 0xda, 0xaa, 0x20, 0x2b, 0x18, 0xa1, 0x94, 0x46,
0x24, 0xa5, 0xb1, 0xe3, 0x8e, 0xb0, 0xc8, 0x40, 0x55, 0x50, 0x7d, 0x4a, 0x79, 0x87, 0x69, 0xaa,
0x38, 0x3d, 0x8c, 0x2f, 0xca, 0x2a, 0xa6, 0x94, 0x1f, 0xbc, 0xc0, 0x72, 0x07, 0xed, 0x02, 0xb4,
0x7c, 0x62, 0x71, 0xd2, 0x3e, 0xb5, 0xb8, 0x96, 0x15, 0x9c, 0xfa, 0x0c, 0xe7, 0xcb, 0xe8, 0x7a,
0x1a, 0x6b, 0xe7, 0x17, 0xe5, 0x95, 0xcf, 0x3f, 0xca, 0x0a, 0xce, 0x49, 0xdc, 0x0e, 0x0f, 0x48,
0x06, 0x5e, 0x3b, 0x22, 0x59, 0x5b, 0x86, 0x44, 0xe2, 0x76, 0xb8, 0xbe, 0x09, 0xf9, 0x09, 0x51,
0xd1, 0x3f, 0x90, 0xee, 0x91, 0x51, 0x78, 0x6f, 0x38, 0x58, 0x06, 0xf2, 0x0e, 0x2d, 0x67, 0x40,
0xb4, 0x54, 0x28, 0xaf, 0x08, 0xb6, 0x52, 0x1b, 0x8a, 0x7e, 0x0c, 0x59, 0x29, 0x13, 0x42, 0x90,
0x71, 0xad, 0x3e, 0x91, 0x38, 0xb1, 0x46, 0x06, 0x64, 0xa9, 0xc7, 0x6d, 0xea, 0x32, 0x01, 0x5d,
0x24, 0x5a, 0x94, 0x54, 0x7d, 0x00, 0xff, 0x1e, 0x12, 0x7e, 0x7d, 0x05, 0x98, 0xbc, 0x1f, 0x10,
0xc6, 0x17, 0x19, 0xa9, 0x7a, 0x06, 0x85, 0x5f, 0xd3, 0x99, 0x47, 0x5d, 0x46, 0xd0, 0x09, 0xe4,
0xae, 0x2f, 0x55, 0xc0, 0xf2, 0xf5, 0xfb, 0xcb, 0x5c, 0x7d, 0x23, 0x13, 0xc8, 0x84, 0x63, 0x92,
0xaa, 0x09, 0xff, 0x1d, 0xd9, 0x2c, 0x2e, 0xc5, 0xe2, 0xd6, 0xd4, 0x8e, 0xed, 0x70, 0x59, 0x27,
0x87, 0x65, 0x54, 0x75, 0xa0, 0x38, 0x0d, 0x90, 0xcd, 0x61, 0x80, 0xb8, 0xac, 0xa6, 0x88, 0x09,
0xb8, 0x49, 0x77, 0x13, 0x2c, 0xd5, 0x77, 0x50, 0xdc, 0x15, 0x9e, 0x98, 0x91, 0xee, 0xef, 0x4b,
0xd1, 0x83, 0xff, 0x67, 0x6a, 0xdd, 0x9a, 0xee, 0x5f, 0x14, 0x28, 0xbe, 0x12, 0x46, 0xbd, 0xfd,
0x93, 0xa1, 0x6d, 0xc8, 0x87, 0x43, 0x21, 0x1e, 0x4c, 0xe9, 0xd8, 0xd9, 0x69, 0x3a, 0x08, 0xde,
0xd4, 0x63, 0x8b, 0xf5, 0xb0, 0x9c, 0xbd, 0x60, 0x1d, 0xc8, 0x32, 0xd3, 0xe8, 0xad, 0xc9, 0xf2,
0x10, 0x8a, 0x7b, 0xc4, 0x21, 0x73, 0x54, 0x59, 0x30, 0x2a, 0xf5, 0xcb, 0x0c, 0x40, 0x6c, 0x46,
0x34, 0x84, 0xf4, 0x21, 0xe1, 0xe8, 0x49, 0x82, 0x36, 0xe6, 0x0c, 0xa4, 0xfe, 0x74, 0x69, 0x9c,
0x94, 0xe2, 0x03, 0x64, 0x82, 0xb1, 0x40, 0x49, 0x9e, 0xfc, 0xb9, 0x03, 0xa7, 0x6f, 0xde, 0x00,
0x29, 0x8b, 0x7f, 0x04, 0x35, 0x74, 0x2e, 0x4a, 0x42, 0x32, 0x7f, 0xa0, 0xf4, 0xad, 0x9b, 0x40,
0xe3, 0x06, 0x42, 0x8f, 0x24, 0x6a, 0x60, 0xbe, 0xef, 0x13, 0x35, 0xb0, 0xc8, 0x89, 0x6f, 0x40,
0x0d, 0x7d, 0x93, 0xa8, 0x81, 0xf9, 0x16, 0xd3, 0x8b, 0x33, 0x13, 0xb1, 0x1f, 0xfc, 0x82, 0x34,
0xde, 0x9e, 0x5f, 0x95, 0x56, 0xbe, 0x5f, 0x95, 0x56, 0x3e, 0x8d, 0x4b, 0xca, 0xf9, 0xb8, 0xa4,
0x7c, 0x1b, 0x97, 0x94, 0xcb, 0x71, 0x49, 0x79, 0x7d, 0xf0, 0x07, 0x7f, 0x55, 0xdb, 0x71, 0xd4,
0x54, 0x45, 0xc5, 0x47, 0x3f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x07, 0x2d, 0x75, 0x3c, 0xa6, 0x09,
0x00, 0x00,
}

2
api/services/containers/v1/containers.proto
View File

@ -57,7 +57,7 @@ message Container {
// Name is the name of the runtime.
string name = 1;
// Options specify additional runtime initialization options.
map<string, string> options = 2;
google.protobuf.Any options = 2;
}
// Runtime specifies which runtime to use for executing this container.
Runtime runtime = 4;

193
api/services/events/v1/container.pb.go
View File

@ -45,6 +45,7 @@ import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"
import google_protobuf1 "github.com/gogo/protobuf/types"
import strings "strings"
import reflect "reflect"
@ -74,8 +75,8 @@ func (*ContainerCreate) ProtoMessage() {}
func (*ContainerCreate) Descriptor() ([]byte, []int) { return fileDescriptorContainer, []int{0} }
type ContainerCreate_Runtime struct {
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
Options map[string]string `protobuf:"bytes,2,rep,name=options" json:"options,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
Options *google_protobuf1.Any `protobuf:"bytes,2,opt,name=options" json:"options,omitempty"`
}
func (m *ContainerCreate_Runtime) Reset() { *m = ContainerCreate_Runtime{} }
@ -170,22 +171,15 @@ func (m *ContainerCreate_Runtime) MarshalTo(dAtA []byte) (int, error) {
i = encodeVarintContainer(dAtA, i, uint64(len(m.Name)))
i += copy(dAtA[i:], m.Name)
}
if len(m.Options) > 0 {
for k, _ := range m.Options {
dAtA[i] = 0x12
i++
v := m.Options[k]
mapSize := 1 + len(k) + sovContainer(uint64(len(k))) + 1 + len(v) + sovContainer(uint64(len(v)))
i = encodeVarintContainer(dAtA, i, uint64(mapSize))
dAtA[i] = 0xa
i++
i = encodeVarintContainer(dAtA, i, uint64(len(k)))
i += copy(dAtA[i:], k)
dAtA[i] = 0x12
i++
i = encodeVarintContainer(dAtA, i, uint64(len(v)))
i += copy(dAtA[i:], v)
if m.Options != nil {
dAtA[i] = 0x12
i++
i = encodeVarintContainer(dAtA, i, uint64(m.Options.Size()))
n2, err := m.Options.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n2
}
return i, nil
}
@ -319,13 +313,9 @@ func (m *ContainerCreate_Runtime) Size() (n int) {
if l > 0 {
n += 1 + l + sovContainer(uint64(l))
}
if len(m.Options) > 0 {
for k, v := range m.Options {
_ = k
_ = v
mapEntrySize := 1 + len(k) + sovContainer(uint64(len(k))) + 1 + len(v) + sovContainer(uint64(len(v)))
n += mapEntrySize + 1 + sovContainer(uint64(mapEntrySize))
}
if m.Options != nil {
l = m.Options.Size()
n += 1 + l + sovContainer(uint64(l))
}
return n
}
@ -395,19 +385,9 @@ func (this *ContainerCreate_Runtime) String() string {
if this == nil {
return "nil"
}
keysForOptions := make([]string, 0, len(this.Options))
for k, _ := range this.Options {
keysForOptions = append(keysForOptions, k)
}
github_com_gogo_protobuf_sortkeys.Strings(keysForOptions)
mapStringForOptions := "map[string]string{"
for _, k := range keysForOptions {
mapStringForOptions += fmt.Sprintf("%v: %v,", k, this.Options[k])
}
mapStringForOptions += "}"
s := strings.Join([]string{`&ContainerCreate_Runtime{`,
`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
`Options:` + mapStringForOptions + `,`,
`Options:` + strings.Replace(fmt.Sprintf("%v", this.Options), "Any", "google_protobuf1.Any", 1) + `,`,
`}`,
}, "")
return s
@ -678,94 +658,11 @@ func (m *ContainerCreate_Runtime) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
var keykey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowContainer
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
keykey |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
var stringLenmapkey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowContainer
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLenmapkey |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLenmapkey := int(stringLenmapkey)
if intStringLenmapkey < 0 {
return ErrInvalidLengthContainer
}
postStringIndexmapkey := iNdEx + intStringLenmapkey
if postStringIndexmapkey > l {
return io.ErrUnexpectedEOF
}
mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
iNdEx = postStringIndexmapkey
if m.Options == nil {
m.Options = make(map[string]string)
m.Options = &google_protobuf1.Any{}
}
if iNdEx < postIndex {
var valuekey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowContainer
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
valuekey |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
var stringLenmapvalue uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowContainer
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLenmapvalue |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLenmapvalue := int(stringLenmapvalue)
if intStringLenmapvalue < 0 {
return ErrInvalidLengthContainer
}
postStringIndexmapvalue := iNdEx + intStringLenmapvalue
if postStringIndexmapvalue > l {
return io.ErrUnexpectedEOF
}
mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
iNdEx = postStringIndexmapvalue
m.Options[mapkey] = mapvalue
} else {
var mapvalue string
m.Options[mapkey] = mapvalue
if err := m.Options.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
@ -1231,31 +1128,31 @@ func init() {
}
var fileDescriptorContainer = []byte{
// 406 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x53, 0xcd, 0xaa, 0xd3, 0x40,
0x18, 0xed, 0x24, 0x35, 0xc5, 0x49, 0xa1, 0x32, 0x74, 0x11, 0x02, 0xa6, 0xa5, 0xab, 0xae, 0x26,
0xb4, 0x82, 0x68, 0x05, 0x17, 0xfd, 0x51, 0x0a, 0x82, 0x32, 0x22, 0x88, 0x20, 0x92, 0x36, 0x63,
0x1c, 0x4c, 0x32, 0x21, 0x99, 0x06, 0xba, 0xf3, 0x09, 0x7c, 0x1e, 0x1f, 0xa1, 0x4b, 0x97, 0xae,
0x8a, 0xcd, 0xea, 0x3e, 0xc6, 0x25, 0x99, 0x24, 0x0d, 0x77, 0x71, 0xb9, 0xb7, 0xdc, 0xdd, 0x99,
0x7c, 0xe7, 0x9c, 0x9c, 0xef, 0xc0, 0x07, 0xdf, 0x7a, 0x4c, 0xfc, 0xd8, 0x6d, 0xf0, 0x96, 0x07,
0xf6, 0x96, 0x87, 0xc2, 0x61, 0x21, 0x8d, 0xdd, 0x26, 0x74, 0x22, 0x66, 0x27, 0x34, 0x4e, 0xd9,
0x96, 0x26, 0x36, 0x4d, 0x69, 0x28, 0x12, 0x3b, 0x9d, 0x9c, 0x19, 0x38, 0x8a, 0xb9, 0xe0, 0xe8,
0xe9, 0x59, 0x82, 0x2b, 0x3a, 0x96, 0x74, 0x9c, 0x4e, 0xcc, 0xbe, 0xc7, 0x3d, 0x5e, 0x30, 0xed,
0x1c, 0x49, 0xd1, 0xe8, 0x4a, 0x81, 0xbd, 0x45, 0xa5, 0x5b, 0xc4, 0xd4, 0x11, 0x14, 0x4d, 0x61,
0xb7, 0xb6, 0xfa, 0xc6, 0x5c, 0x03, 0x0c, 0xc1, 0xf8, 0xf1, 0xbc, 0x97, 0x1d, 0x07, 0x7a, 0x4d,
0x5d, 0x2f, 0x89, 0x5e, 0x93, 0xd6, 0x2e, 0xea, 0xc3, 0x47, 0x2c, 0x70, 0x3c, 0x6a, 0x28, 0x39,
0x99, 0xc8, 0x07, 0xfa, 0x00, 0x3b, 0xf1, 0x2e, 0x14, 0x2c, 0xa0, 0x86, 0x3a, 0x04, 0x63, 0x7d,
0xfa, 0x1c, 0xdf, 0x1a, 0x12, 0xdf, 0x88, 0x82, 0x89, 0x54, 0x93, 0xca, 0xc6, 0xfc, 0x03, 0x60,
0xa7, 0xfc, 0x88, 0x10, 0x6c, 0x87, 0x4e, 0x40, 0x65, 0x3e, 0x52, 0x60, 0xf4, 0x15, 0x76, 0x78,
0x24, 0x18, 0x0f, 0x13, 0x43, 0x19, 0xaa, 0x63, 0x7d, 0xba, 0xb8, 0xec, 0x8f, 0xf8, 0xbd, 0x74,
0x59, 0x85, 0x22, 0xde, 0x93, 0xca, 0xd3, 0x9c, 0xc1, 0x6e, 0x73, 0x80, 0x9e, 0x40, 0xf5, 0x27,
0xdd, 0x97, 0x09, 0x72, 0x98, 0x17, 0x91, 0x3a, 0xfe, 0xae, 0x2e, 0xa2, 0x78, 0xcc, 0x94, 0x17,
0x60, 0xf4, 0xbb, 0x59, 0xf5, 0xa7, 0xc8, 0x7d, 0xd8, 0xaa, 0x09, 0xd4, 0x7c, 0x67, 0x43, 0xfd,
0xc4, 0x50, 0x8b, 0xbd, 0x67, 0x77, 0xdd, 0x5b, 0x26, 0xc1, 0xef, 0x0a, 0xb1, 0x5c, 0xb7, 0x74,
0x42, 0x23, 0xa8, 0xc5, 0x9c, 0x8b, 0xef, 0x89, 0xd1, 0x2e, 0x72, 0xc1, 0xec, 0x38, 0xd0, 0x08,
0xe7, 0xe2, 0xcd, 0x47, 0x52, 0x4e, 0xcc, 0x97, 0x50, 0x6f, 0x48, 0xef, 0x55, 0xc8, 0xaa, 0xd1,
0xc7, 0x92, 0xfa, 0xf4, 0xb2, 0x3e, 0xe6, 0x9f, 0x0f, 0x27, 0xab, 0xf5, 0xef, 0x64, 0xb5, 0x7e,
0x65, 0x16, 0x38, 0x64, 0x16, 0xf8, 0x9b, 0x59, 0xe0, 0x7f, 0x66, 0x81, 0x2f, 0xaf, 0x2f, 0x3c,
0xad, 0x57, 0x12, 0x6d, 0xb4, 0xe2, 0x46, 0x9e, 0x5d, 0x07, 0x00, 0x00, 0xff, 0xff, 0x66, 0x84,
0x14, 0x0e, 0xa3, 0x03, 0x00, 0x00,
// 413 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x53, 0x4d, 0x8b, 0xd5, 0x30,
0x14, 0x9d, 0xbc, 0x8e, 0x7d, 0x98, 0x0a, 0x23, 0xe1, 0x2d, 0x6a, 0xc1, 0xce, 0xa3, 0xab, 0xb7,
0x4a, 0x99, 0x0a, 0xa2, 0x23, 0x08, 0xce, 0x87, 0x32, 0xa0, 0x20, 0x11, 0x41, 0xdc, 0x48, 0xfa,
0x9a, 0xa9, 0xc1, 0x36, 0x29, 0x6d, 0x5a, 0xe8, 0xce, 0x5f, 0xe0, 0xef, 0x9a, 0xa5, 0x4b, 0x57,
0x83, 0xd3, 0xdf, 0xe1, 0x42, 0x9a, 0xb4, 0x9d, 0xe2, 0x42, 0xe4, 0xe1, 0xee, 0xdc, 0xdc, 0x73,
0x6e, 0xce, 0xb9, 0x21, 0xf0, 0x55, 0xca, 0xd5, 0xe7, 0x3a, 0xc6, 0x5b, 0x99, 0x87, 0x5b, 0x29,
0x14, 0xe5, 0x82, 0x95, 0xc9, 0x1c, 0xd2, 0x82, 0x87, 0x15, 0x2b, 0x1b, 0xbe, 0x65, 0x55, 0xc8,
0x1a, 0x26, 0x54, 0x15, 0x36, 0x47, 0xb7, 0x0c, 0x5c, 0x94, 0x52, 0x49, 0xf4, 0xf0, 0x56, 0x82,
0x47, 0x3a, 0x36, 0x74, 0xdc, 0x1c, 0x79, 0xab, 0x54, 0xa6, 0x52, 0x33, 0xc3, 0x1e, 0x19, 0x91,
0xf7, 0x20, 0x95, 0x32, 0xcd, 0x58, 0xa8, 0xab, 0xb8, 0xbe, 0x0c, 0xa9, 0x68, 0x4d, 0x2b, 0xf8,
0x05, 0xe0, 0xc1, 0xe9, 0x38, 0xf2, 0xb4, 0x64, 0x54, 0x31, 0x14, 0xc1, 0x7b, 0xd3, 0x2d, 0x9f,
0x78, 0xe2, 0x82, 0x35, 0xd8, 0xdc, 0x3d, 0x39, 0xe8, 0xae, 0x0f, 0x9d, 0x89, 0x7a, 0x71, 0x46,
0x9c, 0x89, 0x74, 0x91, 0xa0, 0x15, 0xbc, 0xc3, 0x73, 0x9a, 0x32, 0x77, 0xd1, 0x93, 0x89, 0x29,
0xd0, 0x5b, 0xb8, 0x2c, 0x6b, 0xa1, 0x78, 0xce, 0x5c, 0x6b, 0x0d, 0x36, 0x4e, 0xf4, 0x18, 0xff,
0xd5, 0x3f, 0xfe, 0xc3, 0x0a, 0x26, 0x46, 0x4d, 0xc6, 0x31, 0xde, 0x1b, 0xb8, 0x1c, 0xce, 0x10,
0x82, 0xfb, 0x82, 0xe6, 0xcc, 0xd8, 0x23, 0x1a, 0x23, 0x0c, 0x97, 0xb2, 0x50, 0x5c, 0x8a, 0x4a,
0x1b, 0x71, 0xa2, 0x15, 0x36, 0xd9, 0xf1, 0x98, 0x1d, 0xbf, 0x10, 0x2d, 0x19, 0x49, 0xc1, 0xb7,
0xc5, 0x2c, 0xfe, 0xfb, 0x22, 0xf9, 0xbf, 0xf1, 0x09, 0xb4, 0x33, 0x1a, 0xb3, 0xac, 0x72, 0xad,
0xb5, 0xb5, 0x71, 0xa2, 0xe3, 0x7f, 0x4d, 0x6f, 0x9c, 0xe0, 0xd7, 0x5a, 0x7c, 0x2e, 0x54, 0xd9,
0x92, 0x61, 0x12, 0x0a, 0xa0, 0x5d, 0x4a, 0xa9, 0x2e, 0x2b, 0x77, 0x5f, 0xfb, 0x82, 0xdd, 0xf5,
0xa1, 0x4d, 0xa4, 0x54, 0x2f, 0xdf, 0x91, 0xa1, 0xe3, 0x3d, 0x85, 0xce, 0x4c, 0x8a, 0xee, 0x43,
0xeb, 0x0b, 0x6b, 0x87, 0x3d, 0xf5, 0xb0, 0xb7, 0xdb, 0xd0, 0xac, 0x9e, 0xec, 0xea, 0xe2, 0x78,
0xf1, 0x04, 0x04, 0xe7, 0xb3, 0x7d, 0x9c, 0xb1, 0x8c, 0xed, 0xb6, 0x8f, 0x93, 0x0f, 0x57, 0x37,
0xfe, 0xde, 0x8f, 0x1b, 0x7f, 0xef, 0x6b, 0xe7, 0x83, 0xab, 0xce, 0x07, 0xdf, 0x3b, 0x1f, 0xfc,
0xec, 0x7c, 0xf0, 0xf1, 0xf9, 0x8e, 0x3f, 0xe1, 0x99, 0x41, 0xb1, 0xad, 0x1f, 0xf2, 0xd1, 0xef,
0x00, 0x00, 0x00, 0xff, 0xff, 0x1a, 0x0b, 0xcd, 0x09, 0x52, 0x03, 0x00, 0x00,
}

3
api/services/events/v1/container.proto
View File

@ -3,6 +3,7 @@ syntax = "proto3";
package containerd.services.events.v1;
import "gogoproto/gogo.proto";
import "google/protobuf/any.proto";
option go_package = "github.com/containerd/containerd/api/services/events/v1;events";
@ -11,7 +12,7 @@ message ContainerCreate {
string image = 2;
message Runtime {
string name = 1;
map<string, string> options = 2;
google.protobuf.Any options = 2;
}
Runtime runtime = 3;
}

10
api/services/events/v1/events.pb.go
View File

@ -9,7 +9,7 @@ import fmt "fmt"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"
import _ "github.com/gogo/protobuf/types"
import google_protobuf2 "github.com/gogo/protobuf/types"
import google_protobuf1 "github.com/gogo/protobuf/types"
import time "time"
@ -41,7 +41,7 @@ func (*StreamEventsRequest) Descriptor() ([]byte, []int) { return fileDescriptor
type Envelope struct {
Timestamp time.Time `protobuf:"bytes,1,opt,name=timestamp,stdtime" json:"timestamp"`
Topic string `protobuf:"bytes,2,opt,name=topic,proto3" json:"topic,omitempty"`
Event *google_protobuf2.Any `protobuf:"bytes,3,opt,name=event" json:"event,omitempty"`
Event *google_protobuf1.Any `protobuf:"bytes,3,opt,name=event" json:"event,omitempty"`
}
func (m *Envelope) Reset() { *m = Envelope{} }
@ -288,9 +288,9 @@ func (this *Envelope) String() string {
return "nil"
}
s := strings.Join([]string{`&Envelope{`,
`Timestamp:` + strings.Replace(strings.Replace(this.Timestamp.String(), "Timestamp", "google_protobuf1.Timestamp", 1), `&`, ``, 1) + `,`,
`Timestamp:` + strings.Replace(strings.Replace(this.Timestamp.String(), "Timestamp", "google_protobuf2.Timestamp", 1), `&`, ``, 1) + `,`,
`Topic:` + fmt.Sprintf("%v", this.Topic) + `,`,
`Event:` + strings.Replace(fmt.Sprintf("%v", this.Event), "Any", "google_protobuf2.Any", 1) + `,`,
`Event:` + strings.Replace(fmt.Sprintf("%v", this.Event), "Any", "google_protobuf1.Any", 1) + `,`,
`}`,
}, "")
return s
@ -468,7 +468,7 @@ func (m *Envelope) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.Event == nil {
m.Event = &google_protobuf2.Any{}
m.Event = &google_protobuf1.Any{}
}
if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err

6
api/services/events/v1/runtime.pb.go
View File

@ -571,8 +571,8 @@ func (this *RuntimeEvent) String() string {
`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
`Pid:` + fmt.Sprintf("%v", this.Pid) + `,`,
`ExitStatus:` + fmt.Sprintf("%v", this.ExitStatus) + `,`,
`ExitedAt:` + strings.Replace(strings.Replace(this.ExitedAt.String(), "Timestamp", "google_protobuf1.Timestamp", 1), `&`, ``, 1) + `,`,
`Timestamp:` + strings.Replace(strings.Replace(this.Timestamp.String(), "Timestamp", "google_protobuf1.Timestamp", 1), `&`, ``, 1) + `,`,
`ExitedAt:` + strings.Replace(strings.Replace(this.ExitedAt.String(), "Timestamp", "google_protobuf2.Timestamp", 1), `&`, ``, 1) + `,`,
`Timestamp:` + strings.Replace(strings.Replace(this.Timestamp.String(), "Timestamp", "google_protobuf2.Timestamp", 1), `&`, ``, 1) + `,`,
`}`,
}, "")
return s
@ -585,7 +585,7 @@ func (this *RuntimeDelete) String() string {
`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
`Runtime:` + fmt.Sprintf("%v", this.Runtime) + `,`,
`ExitStatus:` + fmt.Sprintf("%v", this.ExitStatus) + `,`,
`ExitedAt:` + strings.Replace(strings.Replace(this.ExitedAt.String(), "Timestamp", "google_protobuf1.Timestamp", 1), `&`, ``, 1) + `,`,
`ExitedAt:` + strings.Replace(strings.Replace(this.ExitedAt.String(), "Timestamp", "google_protobuf2.Timestamp", 1), `&`, ``, 1) + `,`,
`}`,
}, "")
return s

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 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 {
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)
if m.Options != nil {
dAtA[i] = 0x1a
i++
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 {

86
checkpoint_test.go
View File

@ -3,6 +3,8 @@ package containerd
import (
"syscall"
"testing"
"github.com/containerd/containerd/linux/runcopts"
)
func TestCheckpointRestore(t *testing.T) {
@ -62,7 +64,7 @@ func TestCheckpointRestore(t *testing.T) {
return
}
checkpoint, err := task.Checkpoint(ctx, WithExit)
checkpoint, err := task.Checkpoint(ctx, runcopts.WithExit)
if err != nil {
t.Error(err)
return
@ -155,7 +157,7 @@ func TestCheckpointRestoreNewContainer(t *testing.T) {
return
}
checkpoint, err := task.Checkpoint(ctx, WithExit)
checkpoint, err := task.Checkpoint(ctx, runcopts.WithExit)
if err != nil {
t.Error(err)
return
@ -200,3 +202,83 @@ 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
}

2
client.go
View File

@ -195,6 +195,8 @@ func WithNewReadonlyRootFS(id string, i Image) 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) NewContainerOpts {
return func(ctx context.Context, client *Client, c *containers.Container) error {
c.Runtime = &containers.Container_Runtime{

3
cmd/ctr/checkpoint.go
View File

@ -4,6 +4,7 @@ import (
"fmt"
"github.com/containerd/containerd"
"github.com/containerd/containerd/linux/runcopts"
"github.com/pkg/errors"
"github.com/urfave/cli"
)
@ -42,7 +43,7 @@ var checkpointCommand = cli.Command{
}
var opts []containerd.CheckpointOpts
if context.Bool("exit") {
opts = append(opts, containerd.WithExit)
opts = append(opts, runcopts.WithExit)
}
checkpoint, err := task.Checkpoint(ctx, opts...)
if err != nil {

4
containers/containers.go
View File

@ -3,6 +3,8 @@ package containers
import (
"context"
"time"
"github.com/gogo/protobuf/types"
)
// Container represents the set of data pinned by a container. Unless otherwise
@ -22,7 +24,7 @@ type Container struct {
type RuntimeInfo struct {
Name string
Options map[string]string
Options *types.Any
}
type Store interface {

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

@ -0,0 +1,33 @@
package runcopts
import (
"path/filepath"
tasks "github.com/containerd/containerd/api/services/tasks/v1"
"github.com/gogo/protobuf/proto"
protobuf "github.com/gogo/protobuf/types"
)
const URIBase = "types.containerd.io/linux/runc"
func WithExit(r *tasks.CheckpointTaskRequest) error {
a, err := marshal(&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(URIBase, name),
Value: data,
}, nil
}

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;
}

1
linux/runtime.go
View File

@ -171,6 +171,7 @@ func (r *Runtime) Create(ctx context.Context, id string, opts runtime.CreateOpts
Stderr: opts.IO.Stderr,
Terminal: opts.IO.Terminal,
Checkpoint: opts.Checkpoint,
Options: opts.Options,
}
for _, m := range opts.Rootfs {
sopts.Rootfs = append(sopts.Rootfs, &types.Mount{

53
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,
@ -105,10 +113,9 @@ func newInitProcess(context context.Context, path, namespace string, r *shimapi.
WorkDir: filepath.Join(r.Bundle, "work"),
ParentPath: r.ParentCheckpoint,
},
PidFile: pidFile,
IO: io,
// TODO: implement runtime options
//NoPivot: r.NoPivot,
PidFile: pidFile,
IO: io,
NoPivot: options.NoPivotRoot,
Detach: true,
NoSubreaper: true,
}
@ -117,9 +124,10 @@ func newInitProcess(context context.Context, path, namespace string, r *shimapi.
}
} else {
opts := &runc.CreateOpts{
PidFile: pidFile,
IO: io,
// NoPivot: r.NoPivot,
PidFile: pidFile,
IO: io,
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 actions []runc.CheckpointAction
/*
if !r.Exit {
actions = append(actions, runc.LeaveRunning)
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 !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,
*/
WorkDir: work,
ImagePath: r.Path,
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 {

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 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{} }
@ -191,8 +191,8 @@ func (*ListPidsResponse) ProtoMessage() {}
func (*ListPidsResponse) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{11} }
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"`
Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
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 {
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)
if m.Options != nil {
dAtA[i] = 0x12
i++
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 {

17
linux/task.go
View File

@ -11,8 +11,7 @@ import (
client "github.com/containerd/containerd/linux/shim"
shim "github.com/containerd/containerd/linux/shim/v1"
"github.com/containerd/containerd/runtime"
protobuf "github.com/gogo/protobuf/types"
specs "github.com/opencontainers/runtime-spec/specs-go"
"github.com/gogo/protobuf/types"
"github.com/pkg/errors"
)
@ -111,10 +110,7 @@ func (t *Task) Exec(ctx context.Context, opts runtime.ExecOpts) (runtime.Process
Stdout: opts.IO.Stdout,
Stderr: opts.IO.Stderr,
Terminal: opts.IO.Terminal,
Spec: &protobuf.Any{
TypeUrl: specs.Version,
Value: opts.Spec,
},
Spec: opts.Spec,
}
resp, err := t.shim.Exec(ctx, request)
if err != nil {
@ -160,7 +156,7 @@ 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 *types.Any) error {
r := &shim.CheckpointTaskRequest{
Path: path,
Options: options,
@ -185,12 +181,9 @@ func (t *Task) DeleteProcess(ctx context.Context, pid uint32) (*runtime.Exit, er
}, nil
}
func (t *Task) Update(ctx context.Context, resources []byte) error {
func (t *Task) Update(ctx context.Context, resources *types.Any) error {
_, err := t.shim.Update(ctx, &shim.UpdateTaskRequest{
Resources: &protobuf.Any{
TypeUrl: specs.Version,
Value: resources,
},
Resources: resources,
})
return err
}

23
metadata/containers.go
View File

@ -9,6 +9,8 @@ import (
"github.com/containerd/containerd/errdefs"
"github.com/containerd/containerd/identifiers"
"github.com/containerd/containerd/namespaces"
"github.com/gogo/protobuf/proto"
"github.com/gogo/protobuf/types"
"github.com/pkg/errors"
)
@ -166,16 +168,16 @@ func readContainer(container *containers.Container, bkt *bolt.Bucket) error {
container.Runtime.Name = string(n)
}
obkt := rbkt.Bucket(bucketKeyOptions)
obkt := rbkt.Get(bucketKeyOptions)
if obkt == nil {
return nil
}
container.Runtime.Options = map[string]string{}
return obkt.ForEach(func(k, v []byte) error {
container.Runtime.Options[string(k)] = string(v)
return nil
})
var any types.Any
if err := proto.Unmarshal(obkt, &any); err != nil {
return err
}
container.Runtime.Options = &any
case string(bucketKeySpec):
container.Spec = make([]byte, len(v))
copy(container.Spec, v)
@ -249,8 +251,13 @@ func writeContainer(container *containers.Container, bkt *bolt.Bucket) error {
return err
}
for k, v := range container.Runtime.Options {
if err := obkt.Put([]byte(k), []byte(v)); err != nil {
if container.Runtime.Options != nil {
data, err := proto.Marshal(container.Runtime.Options)
if err != nil {
return err
}
if err := obkt.Put(bucketKeyOptions, data); err != nil {
return err
}
}

6
runtime/runtime.go
View File

@ -5,6 +5,7 @@ import (
"time"
"github.com/containerd/containerd/mount"
"github.com/gogo/protobuf/types"
)
type IO struct {
@ -20,8 +21,11 @@ type CreateOpts struct {
// Rootfs mounts to perform to gain access to the container's filesystem
Rootfs []mount.Mount
// IO for the container's main process
IO IO
IO IO
// Checkpoint digest to restore container state
Checkpoint string
// Options for the runtime and container
Options *types.Any
}
type Exit struct {

12
runtime/task.go
View File

@ -1,6 +1,10 @@
package runtime
import "context"
import (
"context"
"github.com/gogo/protobuf/types"
)
type TaskInfo struct {
ID string
@ -32,15 +36,15 @@ 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, *types.Any) error
// DeleteProcess deletes a specific exec process via the pid
DeleteProcess(context.Context, uint32) (*Exit, error)
// Update sets the provided resources to a running task
Update(context.Context, []byte) error
Update(context.Context, *types.Any) error
}
type ExecOpts struct {
Spec []byte
Spec *types.Any
IO IO
}

6
services/tasks/service.go
View File

@ -121,7 +121,6 @@ func (s *Service) Create(ctx context.Context, r *api.CreateTaskRequest) (*api.Cr
if err != nil {
return nil, errdefs.ToGRPC(err)
}
opts := runtime.CreateOpts{
Spec: container.Spec,
IO: runtime.IO{
@ -131,6 +130,7 @@ func (s *Service) Create(ctx context.Context, r *api.CreateTaskRequest) (*api.Cr
Terminal: r.Terminal,
},
Checkpoint: checkpointPath,
Options: r.Options,
}
for _, m := range r.Rootfs {
opts.Rootfs = append(opts.Rootfs, mount.Mount{
@ -357,7 +357,7 @@ func (s *Service) Exec(ctx context.Context, r *api.ExecProcessRequest) (*api.Exe
return nil, err
}
process, err := t.Exec(ctx, runtime.ExecOpts{
Spec: r.Spec.Value,
Spec: r.Spec,
IO: runtime.IO{
Stdin: r.Stdin,
Stdout: r.Stdout,
@ -446,7 +446,7 @@ func (s *Service) Update(ctx context.Context, r *api.UpdateTaskRequest) (*google
if err != nil {
return nil, err
}
if err := t.Update(ctx, r.Resources.Value); err != nil {
if err := t.Update(ctx, r.Resources); err != nil {
return nil, err
}
return empty, nil

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 {

7
windows/container.go
View File

@ -13,6 +13,7 @@ import (
"github.com/containerd/containerd/log"
"github.com/containerd/containerd/runtime"
"github.com/containerd/containerd/windows/hcs"
"github.com/gogo/protobuf/types"
specs "github.com/opencontainers/runtime-spec/specs-go"
"github.com/pkg/errors"
winsys "golang.org/x/sys/windows"
@ -139,7 +140,7 @@ func (c *container) Exec(ctx context.Context, opts runtime.ExecOpts) (runtime.Pr
}
var procSpec specs.Process
if err := json.Unmarshal(opts.Spec, &procSpec); err != nil {
if err := json.Unmarshal(opts.Spec.Value, &procSpec); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal oci spec")
}
@ -187,7 +188,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, _ *types.Any) error {
return fmt.Errorf("Windows containers do not support checkpoint")
}
@ -213,7 +214,7 @@ func (c *container) DeleteProcess(ctx context.Context, pid uint32) (*runtime.Exi
}, nil
}
func (c *container) Update(ctx context.Context, spec []byte) error {
func (c *container) Update(ctx context.Context, spec *types.Any) error {
return fmt.Errorf("Windows containers do not support update")
}