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

Return fifo paths from Shim

Browse Source 
This allows attach of existing fifos to be done without any information
stored on the client side.

Signed-off-by: Michael Crosby <crosbymichael@gmail.com>
This commit is contained in:
Michael Crosby 2017-06-01 13:36:44 -07:00
parent 43fb19e01c
commit 00734ab04a
16 changed files with 682 additions and 191 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -178,6 +178,10 @@ type StateResponse struct {
Pid uint32 `protobuf:"varint,3,opt,name=pid,proto3" json:"pid,omitempty"`
Status containerd_v1_types1.Status `protobuf:"varint,4,opt,name=status,proto3,enum=containerd.v1.types.Status" json:"status,omitempty"`
Processes []*containerd_v1_types1.Process `protobuf:"bytes,5,rep,name=processes" json:"processes,omitempty"`
Stdin string `protobuf:"bytes,6,opt,name=stdin,proto3" json:"stdin,omitempty"`
Stdout string `protobuf:"bytes,7,opt,name=stdout,proto3" json:"stdout,omitempty"`
Stderr string `protobuf:"bytes,8,opt,name=stderr,proto3" json:"stderr,omitempty"`
Terminal bool `protobuf:"varint,9,opt,name=terminal,proto3" json:"terminal,omitempty"`
}
func (m *StateResponse) Reset() { *m = StateResponse{} }
@ -1229,6 +1233,34 @@ func (m *StateResponse) MarshalTo(dAtA []byte) (int, error) {
i += n
}
}
if len(m.Stdin) > 0 {
dAtA[i] = 0x32
i++
i = encodeVarintShim(dAtA, i, uint64(len(m.Stdin)))
i += copy(dAtA[i:], m.Stdin)
}
if len(m.Stdout) > 0 {
dAtA[i] = 0x3a
i++
i = encodeVarintShim(dAtA, i, uint64(len(m.Stdout)))
i += copy(dAtA[i:], m.Stdout)
}
if len(m.Stderr) > 0 {
dAtA[i] = 0x42
i++
i = encodeVarintShim(dAtA, i, uint64(len(m.Stderr)))
i += copy(dAtA[i:], m.Stderr)
}
if m.Terminal {
dAtA[i] = 0x48
i++
if m.Terminal {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i++
}
return i, nil
}
@ -1702,6 +1734,21 @@ func (m *StateResponse) Size() (n int) {
n += 1 + l + sovShim(uint64(l))
}
}
l = len(m.Stdin)
if l > 0 {
n += 1 + l + sovShim(uint64(l))
}
l = len(m.Stdout)
if l > 0 {
n += 1 + l + sovShim(uint64(l))
}
l = len(m.Stderr)
if l > 0 {
n += 1 + l + sovShim(uint64(l))
}
if m.Terminal {
n += 2
}
return n
}
@ -1949,6 +1996,10 @@ func (this *StateResponse) String() string {
`Pid:` + fmt.Sprintf("%v", this.Pid) + `,`,
`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
`Processes:` + strings.Replace(fmt.Sprintf("%v", this.Processes), "Process", "containerd_v1_types1.Process", 1) + `,`,
`Stdin:` + fmt.Sprintf("%v", this.Stdin) + `,`,
`Stdout:` + fmt.Sprintf("%v", this.Stdout) + `,`,
`Stderr:` + fmt.Sprintf("%v", this.Stderr) + `,`,
`Terminal:` + fmt.Sprintf("%v", this.Terminal) + `,`,
`}`,
}, "")
return s
@ -3425,6 +3476,113 @@ func (m *StateResponse) Unmarshal(dAtA []byte) error {
return err
}
iNdEx = postIndex
case 6:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Stdin", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowShim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthShim
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Stdin = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 7:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Stdout", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowShim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthShim
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Stdout = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 8:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Stderr", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowShim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthShim
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Stderr = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 9:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Terminal", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowShim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.Terminal = bool(v != 0)
default:
iNdEx = preIndex
skippy, err := skipShim(dAtA[iNdEx:])
@ -4251,76 +4409,77 @@ func init() {
}
var fileDescriptorShim = []byte{
// 1136 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0xcb, 0x72, 0xe3, 0x44,
0x17, 0x1e, 0xd9, 0x8e, 0x63, 0x1f, 0x8f, 0x9d, 0xa4, 0x2b, 0x95, 0xd2, 0x38, 0xff, 0xef, 0x04,
0x55, 0x4d, 0x8d, 0x93, 0x01, 0x19, 0x32, 0xbb, 0x29, 0x58, 0xe4, 0x46, 0x31, 0x10, 0xc0, 0xd5,
0x09, 0x2b, 0xaa, 0x70, 0x29, 0x72, 0xc7, 0x6e, 0x22, 0xab, 0x85, 0xba, 0x9d, 0x49, 0x76, 0x3c,
0x00, 0x0b, 0xb6, 0x3c, 0x09, 0x7b, 0x56, 0x59, 0xb2, 0x83, 0xd5, 0xc0, 0xe4, 0x49, 0xa8, 0xbe,
0x48, 0xb2, 0x93, 0xc8, 0x4e, 0x36, 0xaa, 0x3e, 0xa7, 0xbf, 0x3e, 0x7d, 0xae, 0x5f, 0x0b, 0x3e,
0x1b, 0x50, 0x31, 0x1c, 0x9f, 0xba, 0x3e, 0x1b, 0x75, 0x7c, 0x16, 0x0a, 0x8f, 0x86, 0x24, 0xee,
0x4f, 0x2e, 0xbd, 0x88, 0x76, 0x38, 0x89, 0x2f, 0xa8, 0x4f, 0x78, 0x87, 0x0f, 0xe9, 0x48, 0x7d,
0xdc, 0x28, 0x66, 0x82, 0xa1, 0xf5, 0x0c, 0xe8, 0x5e, 0x7c, 0xe2, 0x26, 0x38, 0x57, 0x42, 0x9a,
0xcf, 0x06, 0x8c, 0x0d, 0x02, 0xd2, 0x51, 0xd0, 0xd3, 0xf1, 0x59, 0xc7, 0x0b, 0xaf, 0xf4, 0xb9,
0xe6, 0xfa, 0xed, 0x2d, 0x32, 0x8a, 0x44, 0xb2, 0xb9, 0x3a, 0x60, 0x03, 0xa6, 0x96, 0x1d, 0xb9,
0x32, 0xda, 0x4f, 0x1f, 0xe4, 0xa9, 0xb8, 0x8a, 0x08, 0xef, 0x8c, 0xd8, 0x38, 0x14, 0xfa, 0x6b,
0x4e, 0xbf, 0x7e, 0xc4, 0x69, 0xe1, 0xf1, 0x73, 0xf5, 0x31, 0x67, 0x37, 0x6e, 0x3b, 0x2b, 0xe8,
0x88, 0x70, 0xe1, 0x8d, 0x22, 0x0d, 0x70, 0xfe, 0x2a, 0x40, 0x7d, 0x3f, 0x26, 0x9e, 0x20, 0x98,
0xfc, 0x34, 0x26, 0x5c, 0xa0, 0x35, 0x28, 0xd0, 0xbe, 0x6d, 0x6d, 0x5a, 0xed, 0xea, 0x5e, 0xf9,
0xe6, 0xdd, 0x46, 0xe1, 0xcd, 0x01, 0x2e, 0xd0, 0x3e, 0x5a, 0x83, 0xf2, 0xe9, 0x38, 0xec, 0x07,
0xc4, 0x2e, 0xc8, 0x3d, 0x6c, 0x24, 0x64, 0xc3, 0x62, 0x3c, 0x0e, 0xa5, 0x5d, 0xbb, 0xa8, 0x36,
0x12, 0x11, 0x3d, 0x83, 0x4a, 0xc8, 0x7a, 0x11, 0xbd, 0x60, 0xc2, 0x2e, 0x6d, 0x5a, 0xed, 0x0a,
0x5e, 0x0c, 0x59, 0x57, 0x8a, 0xa8, 0x09, 0x15, 0x41, 0xe2, 0x11, 0x0d, 0xbd, 0xc0, 0x5e, 0x50,
0x5b, 0xa9, 0x8c, 0x56, 0x61, 0x81, 0x8b, 0x3e, 0x0d, 0xed, 0xb2, 0x32, 0xa7, 0x05, 0x79, 0x3d,
0x17, 0x7d, 0x36, 0x16, 0xf6, 0xa2, 0xbe, 0x5e, 0x4b, 0x46, 0x4f, 0xe2, 0xd8, 0xae, 0xa4, 0x7a,
0x12, 0xc7, 0x68, 0x07, 0xca, 0x31, 0x63, 0xe2, 0x8c, 0xdb, 0xd5, 0xcd, 0x62, 0xbb, 0xb6, 0xd3,
0x74, 0xa7, 0xeb, 0xad, 0xf2, 0xe5, 0x7e, 0x2d, 0xf3, 0x8c, 0x0d, 0x12, 0xb5, 0x00, 0xfc, 0x21,
0xf1, 0xcf, 0x23, 0x46, 0x43, 0x61, 0x83, 0xb2, 0x37, 0xa1, 0x41, 0x2f, 0x61, 0x25, 0xf2, 0x62,
0x12, 0x8a, 0xde, 0x04, 0xac, 0xa6, 0x60, 0xcb, 0x7a, 0x63, 0x3f, 0xd5, 0x3b, 0x0e, 0x34, 0x92,
0xc4, 0xf2, 0x88, 0x85, 0x9c, 0xa0, 0x65, 0x28, 0x46, 0x26, 0xb5, 0x75, 0x2c, 0x97, 0x4e, 0x03,
0x9e, 0x1e, 0x0b, 0x2f, 0x16, 0x26, 0xf7, 0xce, 0x07, 0x50, 0x3f, 0x20, 0x01, 0xc9, 0x8a, 0x71,
0xf7, 0x88, 0x80, 0x46, 0x02, 0x31, 0x66, 0x37, 0xa0, 0x46, 0x2e, 0xa9, 0xe8, 0x71, 0xe1, 0x89,
0x31, 0x37, 0x58, 0x90, 0xaa, 0x63, 0xa5, 0x41, 0xbb, 0x50, 0x95, 0x12, 0xe9, 0xf7, 0x3c, 0xa1,
0x8a, 0x27, 0xb3, 0xa1, 0x1b, 0xc3, 0x4d, 0x1a, 0xc3, 0x3d, 0x49, 0x1a, 0x63, 0xaf, 0x72, 0xfd,
0x6e, 0xe3, 0xc9, 0xaf, 0xff, 0x6c, 0x58, 0xb8, 0xa2, 0x8f, 0xed, 0x0a, 0xe7, 0x37, 0x0b, 0x6a,
0x87, 0x97, 0xc4, 0x4f, 0xfc, 0x9a, 0xac, 0x9f, 0x95, 0x57, 0xbf, 0xc2, 0xfd, 0xf5, 0x2b, 0xe6,
0xd4, 0xaf, 0x34, 0x55, 0xbf, 0x36, 0x94, 0x78, 0x44, 0x7c, 0xd5, 0x1d, 0xb5, 0x9d, 0xd5, 0x3b,
0xfe, 0xee, 0x86, 0x57, 0x58, 0x21, 0x9c, 0x03, 0x28, 0xe3, 0x80, 0x8e, 0xa8, 0x40, 0x08, 0x4a,
0xb2, 0xac, 0xba, 0x79, 0xb1, 0x5a, 0x4b, 0xdd, 0xd0, 0x8b, 0xfb, 0xca, 0x99, 0x12, 0x56, 0x6b,
0xa9, 0xe3, 0xec, 0x4c, 0x7b, 0x52, 0xc2, 0x6a, 0xed, 0x6c, 0xc2, 0x53, 0x1d, 0x60, 0x6e, 0xb1,
0x8e, 0x00, 0xba, 0xe2, 0x2a, 0xb7, 0x32, 0x32, 0xee, 0xb7, 0xb4, 0x2f, 0x86, 0xea, 0xaa, 0x3a,
0xd6, 0x82, 0x8c, 0x6f, 0x48, 0xe8, 0x60, 0xa8, 0x6f, 0xab, 0x63, 0x23, 0x39, 0x4b, 0x50, 0x3f,
0xbc, 0x20, 0xa1, 0xe0, 0x49, 0xed, 0x75, 0x2f, 0xa4, 0xa5, 0x77, 0xfe, 0xb0, 0xa0, 0x6e, 0x14,
0xc6, 0xa5, 0xc7, 0x4e, 0xa6, 0x71, 0xb1, 0x98, 0xb9, 0xf8, 0x4a, 0x26, 0x5b, 0x75, 0x89, 0x4c,
0x76, 0x63, 0x67, 0xfd, 0xde, 0xa1, 0xd0, 0x6d, 0x83, 0x0d, 0x14, 0xbd, 0x86, 0x6a, 0x14, 0x33,
0x9f, 0x70, 0x4e, 0xb8, 0xbd, 0xa0, 0x86, 0xe9, 0x7f, 0xf7, 0x9e, 0xeb, 0x6a, 0x14, 0xce, 0xe0,
0x32, 0xa8, 0xae, 0x37, 0xe6, 0x69, 0x50, 0x4b, 0x50, 0xc7, 0x84, 0x8f, 0x47, 0xa9, 0xa2, 0x2e,
0xfb, 0x8a, 0xa6, 0x03, 0xf0, 0x06, 0x6a, 0x5f, 0xd1, 0x20, 0xc8, 0xb8, 0xa8, 0xcc, 0xe9, 0x20,
0x69, 0xb2, 0x3a, 0x36, 0x92, 0x8c, 0xcc, 0x0b, 0x02, 0x15, 0x6e, 0x05, 0xcb, 0xe5, 0xdd, 0x58,
0x9d, 0xe7, 0xb0, 0xb2, 0x1f, 0x30, 0x4e, 0x8e, 0x65, 0xfb, 0xe5, 0xcf, 0xd3, 0x36, 0x2c, 0x77,
0x13, 0x77, 0xe7, 0x50, 0xa0, 0xf3, 0x2d, 0xac, 0x4c, 0x60, 0x4d, 0x55, 0xa6, 0xd2, 0x63, 0x3d,
0x2e, 0x3d, 0xbf, 0x14, 0x60, 0x25, 0xa3, 0x8c, 0xe4, 0x7a, 0x04, 0x25, 0x39, 0x78, 0x66, 0xb0,
0xd4, 0x1a, 0xad, 0x43, 0xd5, 0x0b, 0x02, 0xf6, 0xb6, 0x27, 0xfc, 0xc8, 0xc4, 0x5d, 0x51, 0x8a,
0x13, 0x3f, 0x42, 0x1f, 0x02, 0xd2, 0x9b, 0xe3, 0x90, 0x5e, 0xf6, 0x38, 0xf3, 0xcf, 0x89, 0xe0,
0x2a, 0x17, 0x15, 0xbc, 0xac, 0x76, 0xbe, 0x0b, 0xe9, 0xe5, 0xb1, 0xd6, 0xa3, 0xe7, 0xd0, 0x30,
0xa6, 0x92, 0x09, 0xd6, 0xe4, 0x5c, 0xd7, 0xf6, 0x92, 0x31, 0xfe, 0x3f, 0xc0, 0x19, 0x0d, 0x48,
0x2f, 0x60, 0xfe, 0x39, 0x37, 0x24, 0x5d, 0x95, 0x9a, 0x23, 0xa9, 0x40, 0x5b, 0xb0, 0xac, 0x1e,
0xbe, 0x5e, 0xe8, 0x8d, 0x08, 0x8f, 0x3c, 0x9f, 0x70, 0xbb, 0xbc, 0x59, 0x6c, 0x57, 0xf1, 0x92,
0xd2, 0x7f, 0x93, 0xaa, 0xd1, 0x0b, 0x58, 0xca, 0xf8, 0xb2, 0x17, 0x79, 0x62, 0x68, 0x38, 0xbc,
0x91, 0xa9, 0xbb, 0x9e, 0x18, 0xee, 0xfc, 0x5e, 0x85, 0xd2, 0xf1, 0x90, 0x8e, 0x90, 0x07, 0x65,
0xcd, 0x9d, 0x68, 0xdb, 0x9d, 0xf1, 0x4c, 0xbb, 0x53, 0x2f, 0x57, 0xf3, 0xe5, 0x83, 0xb0, 0xa6,
0x6c, 0x5f, 0xc2, 0x82, 0xa2, 0x5e, 0xb4, 0x35, 0xf3, 0xd4, 0x24, 0x3d, 0x37, 0xd7, 0xee, 0xb0,
0xd0, 0xa1, 0x0c, 0x55, 0xba, 0xab, 0x39, 0x79, 0x8e, 0xbb, 0x53, 0xdc, 0x3e, 0xc7, 0xdd, 0x5b,
0x24, 0xff, 0x83, 0x72, 0x57, 0x90, 0xf9, 0xee, 0x66, 0x17, 0x6c, 0x3f, 0x04, 0x6a, 0xec, 0xff,
0x08, 0xd5, 0xb4, 0xb5, 0xd1, 0x47, 0x33, 0x0f, 0xde, 0x1e, 0x97, 0xa6, 0xfb, 0x50, 0x78, 0x96,
0x7a, 0x45, 0x0a, 0x73, 0x62, 0x99, 0x24, 0x8e, 0xdc, 0xd4, 0x1f, 0x41, 0x59, 0x13, 0xca, 0x9c,
0xd4, 0x4f, 0xb1, 0x4e, 0xae, 0xb5, 0x13, 0x80, 0x6c, 0x1c, 0xd1, 0xec, 0xb8, 0xee, 0xcc, 0x6d,
0xae, 0xd5, 0x2f, 0xa0, 0x24, 0x39, 0x0e, 0xb5, 0x67, 0xda, 0x9b, 0xa0, 0xc1, 0x5c, 0x4b, 0x18,
0xca, 0xfa, 0xd1, 0x98, 0x13, 0xed, 0xd4, 0xcb, 0xd2, 0xbc, 0xff, 0xd7, 0x47, 0x61, 0x3e, 0xb6,
0xa4, 0x77, 0x92, 0x72, 0xe7, 0x78, 0x37, 0xc1, 0xca, 0xb9, 0xde, 0x7d, 0x2f, 0xe3, 0x24, 0xfe,
0xdc, 0x38, 0xd3, 0xdf, 0x88, 0xe6, 0xd6, 0x03, 0x90, 0xa6, 0x69, 0x3e, 0x87, 0x62, 0x57, 0x5c,
0xa1, 0x17, 0xb3, 0x5b, 0x26, 0x7d, 0x9f, 0x67, 0x96, 0x38, 0x7d, 0x16, 0xe6, 0x95, 0xf8, 0xf6,
0xfb, 0x91, 0x67, 0x75, 0xcf, 0xbe, 0x7e, 0xdf, 0x7a, 0xf2, 0xf7, 0xfb, 0xd6, 0x93, 0x9f, 0x6f,
0x5a, 0xd6, 0xf5, 0x4d, 0xcb, 0xfa, 0xf3, 0xa6, 0x65, 0xfd, 0x7b, 0xd3, 0xb2, 0x4e, 0xcb, 0x0a,
0xf9, 0xea, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x81, 0x12, 0xdb, 0xb6, 0xae, 0x0c, 0x00, 0x00,
// 1149 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0x4f, 0x6f, 0xe3, 0x44,
0x14, 0x5f, 0x27, 0x69, 0x36, 0x79, 0xd9, 0xa4, 0xed, 0xa8, 0xaa, 0xbc, 0x29, 0xa4, 0xc5, 0xd2,
0x6a, 0xd3, 0x2e, 0x38, 0xd0, 0xbd, 0xad, 0xe0, 0xd0, 0x7f, 0x88, 0x85, 0x02, 0xd1, 0xb4, 0x9c,
0x90, 0x88, 0x5c, 0x67, 0x9a, 0x0c, 0x75, 0x3c, 0xc6, 0x33, 0xe9, 0xb6, 0x37, 0x3e, 0x00, 0x07,
0xae, 0xdc, 0xf9, 0x0e, 0x7c, 0x85, 0x1e, 0xb9, 0xc1, 0x69, 0x61, 0xfb, 0x49, 0xd0, 0xfc, 0xb1,
0x9d, 0xb4, 0x75, 0xd2, 0x4a, 0x5c, 0xac, 0x99, 0x37, 0xbf, 0x79, 0xf3, 0xde, 0xfb, 0xbd, 0x3f,
0x86, 0xcf, 0x06, 0x54, 0x0c, 0xc7, 0x27, 0xae, 0xcf, 0x46, 0x1d, 0x9f, 0x85, 0xc2, 0xa3, 0x21,
0x89, 0xfb, 0x93, 0x4b, 0x2f, 0xa2, 0x1d, 0x4e, 0xe2, 0x73, 0xea, 0x13, 0xde, 0xe1, 0x43, 0x3a,
0x52, 0x1f, 0x37, 0x8a, 0x99, 0x60, 0x68, 0x2d, 0x03, 0xba, 0xe7, 0x9f, 0xb8, 0x09, 0xce, 0x95,
0x90, 0xe6, 0xd3, 0x01, 0x63, 0x83, 0x80, 0x74, 0x14, 0xf4, 0x64, 0x7c, 0xda, 0xf1, 0xc2, 0x4b,
0x7d, 0xaf, 0xb9, 0x76, 0xf3, 0x88, 0x8c, 0x22, 0x91, 0x1c, 0xae, 0x0c, 0xd8, 0x80, 0xa9, 0x65,
0x47, 0xae, 0x8c, 0xf4, 0xd3, 0x7b, 0x59, 0x2a, 0x2e, 0x23, 0xc2, 0x3b, 0x23, 0x36, 0x0e, 0x85,
0xfe, 0x9a, 0xdb, 0xaf, 0x1e, 0x70, 0x5b, 0x78, 0xfc, 0x4c, 0x7d, 0xcc, 0xdd, 0xf5, 0x9b, 0xc6,
0x0a, 0x3a, 0x22, 0x5c, 0x78, 0xa3, 0x48, 0x03, 0x9c, 0xbf, 0x0a, 0x50, 0xdf, 0x8b, 0x89, 0x27,
0x08, 0x26, 0x3f, 0x8d, 0x09, 0x17, 0x68, 0x15, 0x0a, 0xb4, 0x6f, 0x5b, 0x1b, 0x56, 0xbb, 0xba,
0x5b, 0xbe, 0x7e, 0xbb, 0x5e, 0x78, 0xbd, 0x8f, 0x0b, 0xb4, 0x8f, 0x56, 0xa1, 0x7c, 0x32, 0x0e,
0xfb, 0x01, 0xb1, 0x0b, 0xf2, 0x0c, 0x9b, 0x1d, 0xb2, 0xe1, 0x71, 0x3c, 0x0e, 0xa5, 0x5e, 0xbb,
0xa8, 0x0e, 0x92, 0x2d, 0x7a, 0x0a, 0x95, 0x90, 0xf5, 0x22, 0x7a, 0xce, 0x84, 0x5d, 0xda, 0xb0,
0xda, 0x15, 0xfc, 0x38, 0x64, 0x5d, 0xb9, 0x45, 0x4d, 0xa8, 0x08, 0x12, 0x8f, 0x68, 0xe8, 0x05,
0xf6, 0x82, 0x3a, 0x4a, 0xf7, 0x68, 0x05, 0x16, 0xb8, 0xe8, 0xd3, 0xd0, 0x2e, 0x2b, 0x75, 0x7a,
0x23, 0x9f, 0xe7, 0xa2, 0xcf, 0xc6, 0xc2, 0x7e, 0xac, 0x9f, 0xd7, 0x3b, 0x23, 0x27, 0x71, 0x6c,
0x57, 0x52, 0x39, 0x89, 0x63, 0xb4, 0x0d, 0xe5, 0x98, 0x31, 0x71, 0xca, 0xed, 0xea, 0x46, 0xb1,
0x5d, 0xdb, 0x6e, 0xba, 0xd3, 0x7c, 0xab, 0x78, 0xb9, 0x5f, 0xcb, 0x38, 0x63, 0x83, 0x44, 0x2d,
0x00, 0x7f, 0x48, 0xfc, 0xb3, 0x88, 0xd1, 0x50, 0xd8, 0xa0, 0xf4, 0x4d, 0x48, 0xd0, 0x0b, 0x58,
0x8e, 0xbc, 0x98, 0x84, 0xa2, 0x37, 0x01, 0xab, 0x29, 0xd8, 0x92, 0x3e, 0xd8, 0x4b, 0xe5, 0x8e,
0x03, 0x8d, 0x24, 0xb0, 0x3c, 0x62, 0x21, 0x27, 0x68, 0x09, 0x8a, 0x91, 0x09, 0x6d, 0x1d, 0xcb,
0xa5, 0xd3, 0x80, 0x27, 0x47, 0xc2, 0x8b, 0x85, 0x89, 0xbd, 0xf3, 0x01, 0xd4, 0xf7, 0x49, 0x40,
0x32, 0x32, 0x6e, 0x5f, 0x11, 0xd0, 0x48, 0x20, 0x46, 0xed, 0x3a, 0xd4, 0xc8, 0x05, 0x15, 0x3d,
0x2e, 0x3c, 0x31, 0xe6, 0x06, 0x0b, 0x52, 0x74, 0xa4, 0x24, 0x68, 0x07, 0xaa, 0x72, 0x47, 0xfa,
0x3d, 0x4f, 0x28, 0xf2, 0x64, 0x34, 0x74, 0x62, 0xb8, 0x49, 0x62, 0xb8, 0xc7, 0x49, 0x62, 0xec,
0x56, 0xae, 0xde, 0xae, 0x3f, 0xfa, 0xf5, 0x9f, 0x75, 0x0b, 0x57, 0xf4, 0xb5, 0x1d, 0xe1, 0xfc,
0x66, 0x41, 0xed, 0xe0, 0x82, 0xf8, 0x89, 0x5d, 0x93, 0xfc, 0x59, 0x79, 0xfc, 0x15, 0xee, 0xe6,
0xaf, 0x98, 0xc3, 0x5f, 0x69, 0x8a, 0xbf, 0x36, 0x94, 0x78, 0x44, 0x7c, 0x95, 0x1d, 0xb5, 0xed,
0x95, 0x5b, 0xf6, 0xee, 0x84, 0x97, 0x58, 0x21, 0x9c, 0x7d, 0x28, 0xe3, 0x80, 0x8e, 0xa8, 0x40,
0x08, 0x4a, 0x92, 0x56, 0x9d, 0xbc, 0x58, 0xad, 0xa5, 0x6c, 0xe8, 0xc5, 0x7d, 0x65, 0x4c, 0x09,
0xab, 0xb5, 0x94, 0x71, 0x76, 0xaa, 0x2d, 0x29, 0x61, 0xb5, 0x76, 0x36, 0xe0, 0x89, 0x76, 0x30,
0x97, 0xac, 0x43, 0x80, 0xae, 0xb8, 0xcc, 0x65, 0x46, 0xfa, 0xfd, 0x86, 0xf6, 0xc5, 0x50, 0x3d,
0x55, 0xc7, 0x7a, 0x23, 0xfd, 0x1b, 0x12, 0x3a, 0x18, 0xea, 0xd7, 0xea, 0xd8, 0xec, 0x9c, 0x45,
0xa8, 0x1f, 0x9c, 0x93, 0x50, 0xf0, 0x84, 0x7b, 0x9d, 0x0b, 0x29, 0xf5, 0xce, 0xef, 0x05, 0xa8,
0x1b, 0x81, 0x31, 0xe9, 0xa1, 0x95, 0x69, 0x4c, 0x2c, 0x66, 0x26, 0xbe, 0x94, 0xc1, 0x56, 0x59,
0x22, 0x83, 0xdd, 0xd8, 0x5e, 0xbb, 0xb3, 0x28, 0x74, 0xda, 0x60, 0x03, 0x45, 0xaf, 0xa0, 0x1a,
0xc5, 0xcc, 0x27, 0x9c, 0x13, 0x6e, 0x2f, 0xa8, 0x62, 0x7a, 0xef, 0xce, 0x7b, 0x5d, 0x8d, 0xc2,
0x19, 0xfc, 0x7f, 0xaa, 0xe5, 0xc9, 0x6c, 0xab, 0x4e, 0x67, 0x9b, 0x0c, 0x5b, 0xd7, 0x1b, 0xf3,
0x34, 0x6c, 0x8b, 0x50, 0xc7, 0x84, 0x8f, 0x47, 0xa9, 0xa0, 0x2e, 0x33, 0x97, 0xa6, 0x25, 0xf6,
0x1a, 0x6a, 0x5f, 0xd1, 0x20, 0xc8, 0xba, 0x5d, 0x99, 0xd3, 0x41, 0x92, 0xc6, 0x75, 0x6c, 0x76,
0x32, 0x76, 0x5e, 0x10, 0xa8, 0x80, 0x56, 0xb0, 0x5c, 0xde, 0x8e, 0xa6, 0xf3, 0x0c, 0x96, 0xf7,
0x02, 0xc6, 0xc9, 0x91, 0x74, 0x2a, 0xbf, 0x62, 0xb7, 0x60, 0xa9, 0x9b, 0x04, 0x64, 0x4e, 0x93,
0x75, 0xbe, 0x85, 0xe5, 0x09, 0xac, 0xe1, 0x7d, 0x8a, 0x00, 0xeb, 0x41, 0x04, 0x38, 0xbf, 0x14,
0x60, 0x39, 0x6b, 0x4a, 0xc9, 0xf3, 0x08, 0x4a, 0xb2, 0xb4, 0x4d, 0xe9, 0xaa, 0x35, 0x5a, 0x83,
0xaa, 0x17, 0x04, 0xec, 0x4d, 0x4f, 0xf8, 0x91, 0xf1, 0xbb, 0xa2, 0x04, 0xc7, 0x7e, 0x84, 0x3e,
0x04, 0xa4, 0x0f, 0xc7, 0x21, 0xbd, 0xe8, 0x71, 0xe6, 0x9f, 0x11, 0xc1, 0x55, 0x2c, 0x2a, 0x78,
0x49, 0x9d, 0x7c, 0x17, 0xd2, 0x8b, 0x23, 0x2d, 0x47, 0xcf, 0xa0, 0x61, 0x54, 0x25, 0xac, 0xe9,
0xf6, 0x5f, 0xd7, 0xfa, 0x92, 0x46, 0xf1, 0x3e, 0xc0, 0x29, 0x0d, 0x48, 0x2f, 0x60, 0xfe, 0x19,
0x37, 0x63, 0xa0, 0x2a, 0x25, 0x87, 0x52, 0x80, 0x36, 0x61, 0x49, 0x8d, 0xd6, 0x5e, 0xe8, 0x8d,
0x08, 0x8f, 0x3c, 0x9f, 0x70, 0xbb, 0xbc, 0x51, 0x6c, 0x57, 0xf1, 0xa2, 0x92, 0x7f, 0x93, 0x8a,
0xd1, 0x73, 0x58, 0xcc, 0x3a, 0x72, 0x2f, 0xf2, 0xc4, 0xd0, 0x64, 0x56, 0x23, 0x13, 0x77, 0x3d,
0x31, 0xdc, 0xfe, 0xa3, 0x0a, 0xa5, 0xa3, 0x21, 0x1d, 0x21, 0x0f, 0xca, 0xba, 0x3b, 0xa3, 0x2d,
0x77, 0xc6, 0x8f, 0x80, 0x3b, 0x35, 0x1b, 0x9b, 0x2f, 0xee, 0x85, 0x35, 0xb4, 0x7d, 0x09, 0x0b,
0xaa, 0xb9, 0xa3, 0xcd, 0x99, 0xb7, 0x26, 0x07, 0x40, 0x73, 0xf5, 0x56, 0x9f, 0x3b, 0x90, 0xae,
0x4a, 0x73, 0x75, 0xd7, 0x9f, 0x63, 0xee, 0xd4, 0xf4, 0x98, 0x63, 0xee, 0x8d, 0x31, 0xf2, 0x83,
0x32, 0x57, 0x90, 0xf9, 0xe6, 0x66, 0x0f, 0x6c, 0xdd, 0x07, 0x6a, 0xf4, 0xff, 0x08, 0xd5, 0x34,
0xb5, 0xd1, 0x47, 0x33, 0x2f, 0xde, 0x2c, 0x97, 0xa6, 0x7b, 0x5f, 0x78, 0x16, 0x7a, 0xd5, 0x14,
0xe6, 0xf8, 0x32, 0xd9, 0x38, 0x72, 0x43, 0x7f, 0x08, 0x65, 0xdd, 0x50, 0xe6, 0x84, 0x7e, 0xaa,
0xeb, 0xe4, 0x6a, 0x3b, 0x06, 0xc8, 0xca, 0x11, 0xcd, 0xf6, 0xeb, 0x56, 0xdd, 0xe6, 0x6a, 0xfd,
0x02, 0x4a, 0xb2, 0xc7, 0xa1, 0xf6, 0x4c, 0x7d, 0x13, 0x6d, 0x30, 0x57, 0x13, 0x86, 0xb2, 0x1e,
0x4b, 0x73, 0xbc, 0x9d, 0x9a, 0x5d, 0xcd, 0xbb, 0x7f, 0xae, 0x14, 0xe6, 0x63, 0x4b, 0x5a, 0x27,
0x5b, 0xee, 0x1c, 0xeb, 0x26, 0xba, 0x72, 0xae, 0x75, 0xdf, 0x4b, 0x3f, 0x89, 0x3f, 0xd7, 0xcf,
0xf4, 0x47, 0xa5, 0xb9, 0x79, 0x0f, 0xa4, 0x49, 0x9a, 0xcf, 0xa1, 0xd8, 0x15, 0x97, 0xe8, 0xf9,
0xec, 0x94, 0x49, 0xff, 0x00, 0x66, 0x52, 0x9c, 0x8e, 0x85, 0x79, 0x14, 0xdf, 0x9c, 0x1f, 0x79,
0x5a, 0x77, 0xed, 0xab, 0x77, 0xad, 0x47, 0x7f, 0xbf, 0x6b, 0x3d, 0xfa, 0xf9, 0xba, 0x65, 0x5d,
0x5d, 0xb7, 0xac, 0x3f, 0xaf, 0x5b, 0xd6, 0xbf, 0xd7, 0x2d, 0xeb, 0xa4, 0xac, 0x90, 0x2f, 0xff,
0x0b, 0x00, 0x00, 0xff, 0xff, 0xa8, 0x64, 0xea, 0xc1, 0x10, 0x0d, 0x00, 0x00,
}

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

@ -97,6 +97,10 @@ message StateResponse {
uint32 pid = 3;
containerd.v1.types.Status status = 4;
repeated containerd.v1.types.Process processes = 5;
string stdin = 6;
string stdout = 7;
string stderr = 8;
bool terminal = 9;
}
message PauseRequest {

377
api/types/task/task.pb.go
View File

@ -113,6 +113,10 @@ type Task struct {
Pid uint32 `protobuf:"varint,3,opt,name=pid,proto3" json:"pid,omitempty"`
Status Status `protobuf:"varint,4,opt,name=status,proto3,enum=containerd.v1.types.Status" json:"status,omitempty"`
Spec *google_protobuf1.Any `protobuf:"bytes,5,opt,name=spec" json:"spec,omitempty"`
Stdin string `protobuf:"bytes,6,opt,name=stdin,proto3" json:"stdin,omitempty"`
Stdout string `protobuf:"bytes,7,opt,name=stdout,proto3" json:"stdout,omitempty"`
Stderr string `protobuf:"bytes,8,opt,name=stderr,proto3" json:"stderr,omitempty"`
Terminal bool `protobuf:"varint,9,opt,name=terminal,proto3" json:"terminal,omitempty"`
}
func (m *Task) Reset() { *m = Task{} }
@ -129,6 +133,9 @@ type Process struct {
ExitStatus uint32 `protobuf:"varint,7,opt,name=exit_status,json=exitStatus,proto3" json:"exit_status,omitempty"`
Status Status `protobuf:"varint,8,opt,name=status,proto3,enum=containerd.v1.types.Status" json:"status,omitempty"`
RuntimeData *google_protobuf1.Any `protobuf:"bytes,9,opt,name=runtime_data,json=runtimeData" json:"runtime_data,omitempty"`
Stdin string `protobuf:"bytes,10,opt,name=stdin,proto3" json:"stdin,omitempty"`
Stdout string `protobuf:"bytes,11,opt,name=stdout,proto3" json:"stdout,omitempty"`
Stderr string `protobuf:"bytes,12,opt,name=stderr,proto3" json:"stderr,omitempty"`
}
func (m *Process) Reset() { *m = Process{} }
@ -212,6 +219,34 @@ func (m *Task) MarshalTo(dAtA []byte) (int, error) {
}
i += n1
}
if len(m.Stdin) > 0 {
dAtA[i] = 0x32
i++
i = encodeVarintTask(dAtA, i, uint64(len(m.Stdin)))
i += copy(dAtA[i:], m.Stdin)
}
if len(m.Stdout) > 0 {
dAtA[i] = 0x3a
i++
i = encodeVarintTask(dAtA, i, uint64(len(m.Stdout)))
i += copy(dAtA[i:], m.Stdout)
}
if len(m.Stderr) > 0 {
dAtA[i] = 0x42
i++
i = encodeVarintTask(dAtA, i, uint64(len(m.Stderr)))
i += copy(dAtA[i:], m.Stderr)
}
if m.Terminal {
dAtA[i] = 0x48
i++
if m.Terminal {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i++
}
return i, nil
}
@ -311,6 +346,24 @@ func (m *Process) MarshalTo(dAtA []byte) (int, error) {
}
i += n3
}
if len(m.Stdin) > 0 {
dAtA[i] = 0x52
i++
i = encodeVarintTask(dAtA, i, uint64(len(m.Stdin)))
i += copy(dAtA[i:], m.Stdin)
}
if len(m.Stdout) > 0 {
dAtA[i] = 0x5a
i++
i = encodeVarintTask(dAtA, i, uint64(len(m.Stdout)))
i += copy(dAtA[i:], m.Stdout)
}
if len(m.Stderr) > 0 {
dAtA[i] = 0x62
i++
i = encodeVarintTask(dAtA, i, uint64(len(m.Stderr)))
i += copy(dAtA[i:], m.Stderr)
}
return i, nil
}
@ -454,6 +507,21 @@ func (m *Task) Size() (n int) {
l = m.Spec.Size()
n += 1 + l + sovTask(uint64(l))
}
l = len(m.Stdin)
if l > 0 {
n += 1 + l + sovTask(uint64(l))
}
l = len(m.Stdout)
if l > 0 {
n += 1 + l + sovTask(uint64(l))
}
l = len(m.Stderr)
if l > 0 {
n += 1 + l + sovTask(uint64(l))
}
if m.Terminal {
n += 2
}
return n
}
@ -496,6 +564,18 @@ func (m *Process) Size() (n int) {
l = m.RuntimeData.Size()
n += 1 + l + sovTask(uint64(l))
}
l = len(m.Stdin)
if l > 0 {
n += 1 + l + sovTask(uint64(l))
}
l = len(m.Stdout)
if l > 0 {
n += 1 + l + sovTask(uint64(l))
}
l = len(m.Stderr)
if l > 0 {
n += 1 + l + sovTask(uint64(l))
}
return n
}
@ -562,6 +642,10 @@ func (this *Task) String() string {
`Pid:` + fmt.Sprintf("%v", this.Pid) + `,`,
`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
`Spec:` + strings.Replace(fmt.Sprintf("%v", this.Spec), "Any", "google_protobuf1.Any", 1) + `,`,
`Stdin:` + fmt.Sprintf("%v", this.Stdin) + `,`,
`Stdout:` + fmt.Sprintf("%v", this.Stdout) + `,`,
`Stderr:` + fmt.Sprintf("%v", this.Stderr) + `,`,
`Terminal:` + fmt.Sprintf("%v", this.Terminal) + `,`,
`}`,
}, "")
return s
@ -580,6 +664,9 @@ func (this *Process) String() string {
`ExitStatus:` + fmt.Sprintf("%v", this.ExitStatus) + `,`,
`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
`RuntimeData:` + strings.Replace(fmt.Sprintf("%v", this.RuntimeData), "Any", "google_protobuf1.Any", 1) + `,`,
`Stdin:` + fmt.Sprintf("%v", this.Stdin) + `,`,
`Stdout:` + fmt.Sprintf("%v", this.Stdout) + `,`,
`Stderr:` + fmt.Sprintf("%v", this.Stderr) + `,`,
`}`,
}, "")
return s
@ -776,6 +863,113 @@ func (m *Task) Unmarshal(dAtA []byte) error {
return err
}
iNdEx = postIndex
case 6:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Stdin", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTask
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthTask
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Stdin = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 7:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Stdout", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTask
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthTask
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Stdout = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 8:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Stderr", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTask
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthTask
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Stderr = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 9:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Terminal", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTask
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.Terminal = bool(v != 0)
default:
iNdEx = preIndex
skippy, err := skipTask(dAtA[iNdEx:])
@ -1056,6 +1250,93 @@ func (m *Process) Unmarshal(dAtA []byte) error {
return err
}
iNdEx = postIndex
case 10:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Stdin", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTask
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthTask
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Stdin = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 11:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Stdout", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTask
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthTask
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Stdout = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 12:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Stderr", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTask
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthTask
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Stderr = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipTask(dAtA[iNdEx:])
@ -1503,50 +1784,54 @@ func init() {
}
var fileDescriptorTask = []byte{
// 718 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0xbf, 0x6f, 0xf3, 0x44,
0x18, 0xce, 0x39, 0xce, 0xaf, 0x4b, 0x93, 0xcf, 0x1c, 0x9f, 0x90, 0xbf, 0x80, 0x1c, 0x2b, 0x42,
0x22, 0x42, 0xc2, 0x11, 0xe9, 0x00, 0x62, 0x4b, 0x63, 0xab, 0x8a, 0x10, 0x49, 0xb8, 0x38, 0xa2,
0x5b, 0x74, 0xcd, 0x1d, 0xe6, 0xd4, 0xc6, 0xb6, 0xec, 0x73, 0x4b, 0x36, 0x46, 0xd4, 0x89, 0x7f,
0xa0, 0x0b, 0xb0, 0xb2, 0x32, 0xb0, 0xb2, 0x74, 0x64, 0x64, 0x2a, 0x34, 0x7f, 0x09, 0xf2, 0xd9,
0xf9, 0xa1, 0x36, 0x20, 0x16, 0xeb, 0xbd, 0xf7, 0x79, 0xee, 0xbd, 0xe7, 0x79, 0xee, 0x0c, 0x3f,
0xf3, 0xb8, 0xf8, 0x26, 0xb9, 0xb4, 0x96, 0xc1, 0xaa, 0xb7, 0x0c, 0x7c, 0x41, 0xb8, 0xcf, 0x22,
0x7a, 0x58, 0x92, 0x90, 0xf7, 0xc4, 0x3a, 0x64, 0x71, 0x4f, 0x90, 0xf8, 0x4a, 0x7e, 0xac, 0x30,
0x0a, 0x44, 0x80, 0xde, 0xde, 0xb3, 0xac, 0x9b, 0x8f, 0x2d, 0x49, 0x6a, 0xbd, 0xf6, 0x02, 0x2f,
0x90, 0x78, 0x2f, 0xad, 0x32, 0x6a, 0xeb, 0x8d, 0x17, 0x04, 0xde, 0x35, 0xeb, 0xc9, 0xd5, 0x65,
0xf2, 0x75, 0x8f, 0xf8, 0xeb, 0x1c, 0x6a, 0x3f, 0x87, 0x04, 0x5f, 0xb1, 0x58, 0x90, 0x55, 0x98,
0x11, 0x3a, 0xbf, 0x03, 0xa8, 0xba, 0x24, 0xbe, 0x42, 0xef, 0x40, 0x85, 0x53, 0x1d, 0x98, 0xa0,
0x5b, 0x3b, 0x2b, 0x6f, 0x1e, 0xdb, 0xca, 0xc8, 0xc6, 0x0a, 0xa7, 0xa8, 0x0f, 0x4f, 0x76, 0x4a,
0x16, 0x9c, 0xea, 0x8a, 0x64, 0xbc, 0xda, 0x3c, 0xb6, 0xeb, 0xc3, 0x6d, 0x7f, 0x64, 0xe3, 0xfa,
0x8e, 0x34, 0xa2, 0x48, 0x83, 0xc5, 0x90, 0x53, 0xbd, 0x68, 0x82, 0x6e, 0x03, 0xa7, 0x25, 0x3a,
0x85, 0xe5, 0x58, 0x10, 0x91, 0xc4, 0xba, 0x6a, 0x82, 0x6e, 0xb3, 0xff, 0xae, 0x75, 0xc4, 0x9e,
0x35, 0x93, 0x14, 0x9c, 0x53, 0x51, 0x17, 0xaa, 0x71, 0xc8, 0x96, 0x7a, 0xc9, 0x04, 0xdd, 0x7a,
0xff, 0xb5, 0x95, 0x79, 0xb1, 0xb6, 0x5e, 0xac, 0x81, 0xbf, 0xc6, 0x92, 0xd1, 0xf9, 0x45, 0x81,
0x95, 0x69, 0x14, 0x2c, 0x59, 0x1c, 0x6f, 0x0f, 0x07, 0xfb, 0xc3, 0x11, 0x54, 0x49, 0xe4, 0xc5,
0xba, 0x62, 0x16, 0xbb, 0x35, 0x2c, 0xeb, 0x94, 0xc5, 0xfc, 0x1b, 0xbd, 0x28, 0x5b, 0x69, 0x89,
0x3e, 0x82, 0x6a, 0x12, 0xb3, 0x48, 0x0a, 0xac, 0xf7, 0xdf, 0x1c, 0x15, 0x38, 0x8f, 0x59, 0x84,
0x25, 0x2d, 0x1d, 0xb0, 0xbc, 0xa5, 0x52, 0x5b, 0x0d, 0xa7, 0x25, 0x6a, 0xc1, 0xaa, 0x60, 0xd1,
0x8a, 0xfb, 0xe4, 0x5a, 0x2f, 0x9b, 0xa0, 0x5b, 0xc5, 0xbb, 0x35, 0x6a, 0xc3, 0x3a, 0xfb, 0x96,
0x8b, 0x45, 0x1e, 0x42, 0x45, 0x8a, 0x83, 0x69, 0x2b, 0xf3, 0x7c, 0x10, 0x50, 0xf5, 0xff, 0x07,
0xf4, 0x09, 0x3c, 0x89, 0x12, 0x3f, 0xbd, 0xd2, 0x05, 0x25, 0x82, 0xe8, 0xb5, 0xff, 0x08, 0xaa,
0x9e, 0x33, 0x6d, 0x22, 0x48, 0x67, 0x06, 0xd5, 0x79, 0x6e, 0x22, 0xd9, 0x67, 0x95, 0x70, 0x79,
0x75, 0x5e, 0x7e, 0xcb, 0x0d, 0x9c, 0x96, 0xe8, 0x03, 0xf8, 0x8a, 0x50, 0xca, 0x05, 0x0f, 0x7c,
0x72, 0xbd, 0xf0, 0x38, 0x8d, 0x65, 0x6a, 0x0d, 0xdc, 0xdc, 0xb7, 0xcf, 0x39, 0x8d, 0x3b, 0x3f,
0x2a, 0xb0, 0xe4, 0xdc, 0x30, 0x5f, 0xfc, 0xeb, 0x5b, 0xfa, 0x14, 0xaa, 0xa9, 0x0f, 0x39, 0xbd,
0xd9, 0x7f, 0xff, 0xa8, 0x45, 0x39, 0x21, 0xfb, 0xba, 0xeb, 0x90, 0x61, 0xb9, 0xe3, 0xc8, 0x8b,
0x7a, 0x96, 0xa8, 0xfa, 0x22, 0xd1, 0x01, 0xac, 0xa5, 0x2b, 0x46, 0x17, 0x44, 0xe4, 0x4f, 0xa8,
0xf5, 0x22, 0x19, 0x77, 0xfb, 0x3b, 0x9c, 0x55, 0x1f, 0x1e, 0xdb, 0x85, 0x1f, 0xfe, 0x6a, 0x03,
0x5c, 0xcd, 0xb6, 0x0d, 0x44, 0xe7, 0x4b, 0x58, 0xdb, 0x09, 0x41, 0x55, 0xa8, 0x3a, 0x17, 0x23,
0x57, 0x2b, 0xa0, 0x0a, 0x2c, 0x4e, 0x26, 0x5f, 0x68, 0x00, 0x41, 0x58, 0x1e, 0x62, 0x67, 0xe0,
0x3a, 0x9a, 0x82, 0x6a, 0xb0, 0x34, 0x73, 0x07, 0xd8, 0xd5, 0x8a, 0xa8, 0x09, 0xa1, 0x73, 0xe1,
0x0c, 0x17, 0x03, 0xdb, 0x76, 0x6c, 0x4d, 0x4d, 0x69, 0xd3, 0xc1, 0x7c, 0xe6, 0xd8, 0x5a, 0xe9,
0xc3, 0x5f, 0x01, 0x2c, 0xe7, 0x02, 0x0d, 0x58, 0x99, 0x8f, 0x3f, 0x1f, 0x4f, 0xbe, 0x1a, 0x6b,
0x85, 0xd6, 0x5b, 0x77, 0xf7, 0x66, 0x23, 0x03, 0xe6, 0xfe, 0x95, 0x1f, 0xdc, 0xfa, 0x29, 0x9e,
0x4d, 0xb7, 0x35, 0x70, 0x88, 0x0f, 0x23, 0x46, 0x04, 0xa3, 0x29, 0x8e, 0xe7, 0xe3, 0xf1, 0x68,
0x7c, 0xae, 0x29, 0x87, 0x38, 0x4e, 0x7c, 0x9f, 0xfb, 0x5e, 0x8a, 0xcf, 0xdc, 0xc9, 0x74, 0xea,
0xd8, 0x5a, 0xf1, 0x10, 0x9f, 0x89, 0x20, 0x0c, 0x19, 0x45, 0xef, 0xed, 0x64, 0xa9, 0x2d, 0xed,
0xee, 0xde, 0x3c, 0xc9, 0xe0, 0x29, 0x49, 0x62, 0x46, 0x5b, 0xcd, 0xef, 0x7f, 0x32, 0x0a, 0xbf,
0xfd, 0x6c, 0xe4, 0x6a, 0xcf, 0xf4, 0x87, 0x27, 0xa3, 0xf0, 0xe7, 0x93, 0x51, 0xf8, 0x6e, 0x63,
0x80, 0x87, 0x8d, 0x01, 0xfe, 0xd8, 0x18, 0xe0, 0xef, 0x8d, 0x01, 0x2e, 0xcb, 0x32, 0xcd, 0xd3,
0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x51, 0xea, 0x99, 0x62, 0xee, 0x04, 0x00, 0x00,
// 775 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0x4d, 0x6f, 0xe3, 0x44,
0x18, 0x8e, 0x1d, 0xe7, 0x6b, 0xd2, 0x66, 0xcd, 0x50, 0xad, 0xbc, 0x01, 0x39, 0x56, 0x84, 0x44,
0x84, 0x84, 0x23, 0xb2, 0x07, 0x10, 0xb7, 0xb4, 0xb6, 0x56, 0x11, 0x22, 0x0d, 0x13, 0x47, 0xec,
0x2d, 0x9a, 0x66, 0x06, 0x33, 0x6a, 0x3b, 0xb6, 0x3c, 0xe3, 0x2e, 0xbd, 0x71, 0x44, 0x7b, 0xe2,
0x0f, 0xec, 0x85, 0x8f, 0xbf, 0xc0, 0x81, 0x5f, 0xd0, 0x23, 0x47, 0x4e, 0x85, 0xcd, 0x5f, 0xe0,
0x0f, 0xa0, 0x19, 0xbb, 0x49, 0x76, 0x9b, 0x4a, 0x7b, 0xb1, 0xde, 0x79, 0x9f, 0x67, 0x26, 0xcf,
0xfb, 0x3c, 0x6f, 0xc0, 0x97, 0x31, 0x93, 0xdf, 0xe7, 0x67, 0xfe, 0x2a, 0xb9, 0x1c, 0xae, 0x12,
0x2e, 0x31, 0xe3, 0x34, 0x23, 0xbb, 0x25, 0x4e, 0xd9, 0x50, 0x5e, 0xa7, 0x54, 0x0c, 0x25, 0x16,
0xe7, 0xfa, 0xe3, 0xa7, 0x59, 0x22, 0x13, 0xf8, 0xfe, 0x96, 0xe5, 0x5f, 0x7d, 0xe6, 0x6b, 0x52,
0xf7, 0x28, 0x4e, 0xe2, 0x44, 0xe3, 0x43, 0x55, 0x15, 0xd4, 0xee, 0x93, 0x38, 0x49, 0xe2, 0x0b,
0x3a, 0xd4, 0xa7, 0xb3, 0xfc, 0xbb, 0x21, 0xe6, 0xd7, 0x25, 0xd4, 0x7b, 0x1b, 0x92, 0xec, 0x92,
0x0a, 0x89, 0x2f, 0xd3, 0x82, 0xd0, 0xff, 0xdd, 0x04, 0x56, 0x84, 0xc5, 0x39, 0x7c, 0x0c, 0x4c,
0x46, 0x1c, 0xc3, 0x33, 0x06, 0xad, 0xe3, 0xfa, 0xfa, 0xb6, 0x67, 0x4e, 0x02, 0x64, 0x32, 0x02,
0x47, 0xe0, 0x60, 0xa3, 0x64, 0xc9, 0x88, 0x63, 0x6a, 0xc6, 0xa3, 0xf5, 0x6d, 0xaf, 0x7d, 0x72,
0xd7, 0x9f, 0x04, 0xa8, 0xbd, 0x21, 0x4d, 0x08, 0xb4, 0x41, 0x35, 0x65, 0xc4, 0xa9, 0x7a, 0xc6,
0xe0, 0x10, 0xa9, 0x12, 0x3e, 0x05, 0x75, 0x21, 0xb1, 0xcc, 0x85, 0x63, 0x79, 0xc6, 0xa0, 0x33,
0xfa, 0xc0, 0xdf, 0x33, 0x9e, 0x3f, 0xd7, 0x14, 0x54, 0x52, 0xe1, 0x00, 0x58, 0x22, 0xa5, 0x2b,
0xa7, 0xe6, 0x19, 0x83, 0xf6, 0xe8, 0xc8, 0x2f, 0x66, 0xf1, 0xef, 0x66, 0xf1, 0xc7, 0xfc, 0x1a,
0x69, 0x06, 0x3c, 0x02, 0x35, 0x21, 0x09, 0xe3, 0x4e, 0x5d, 0xa9, 0x43, 0xc5, 0x01, 0x3e, 0x56,
0x3f, 0x4a, 0x92, 0x5c, 0x3a, 0x0d, 0xdd, 0x2e, 0x4f, 0x65, 0x9f, 0x66, 0x99, 0xd3, 0xdc, 0xf4,
0x69, 0x96, 0xc1, 0x2e, 0x68, 0x4a, 0x9a, 0x5d, 0x32, 0x8e, 0x2f, 0x9c, 0x96, 0x67, 0x0c, 0x9a,
0x68, 0x73, 0xee, 0xff, 0x67, 0x82, 0xc6, 0x2c, 0x4b, 0x56, 0x54, 0x88, 0xbb, 0xf1, 0x8c, 0xed,
0x78, 0x10, 0x58, 0x38, 0x8b, 0x85, 0x63, 0x7a, 0xd5, 0x41, 0x0b, 0xe9, 0x5a, 0xb1, 0x28, 0xbf,
0x72, 0xaa, 0xba, 0xa5, 0x4a, 0xf8, 0x29, 0xb0, 0x72, 0x41, 0x33, 0x6d, 0x41, 0x7b, 0xf4, 0x64,
0xaf, 0x05, 0x0b, 0x41, 0x33, 0xa4, 0x69, 0xea, 0x81, 0xd5, 0x0b, 0xa2, 0xa7, 0x6f, 0x21, 0x55,
0xbe, 0x21, 0xb0, 0xfe, 0xa6, 0x40, 0xd8, 0x03, 0x6d, 0xfa, 0x03, 0x93, 0xcb, 0xd2, 0xe6, 0x86,
0x16, 0x07, 0x54, 0xab, 0x70, 0x75, 0x27, 0x82, 0xe6, 0xbb, 0x47, 0xf0, 0x39, 0x38, 0xc8, 0x72,
0xae, 0x96, 0x66, 0x49, 0xb0, 0xc4, 0xda, 0x96, 0x87, 0xa2, 0x68, 0x97, 0xcc, 0x00, 0x4b, 0xbc,
0x4d, 0x04, 0xec, 0x4f, 0xa4, 0xfd, 0x40, 0x22, 0x07, 0xbb, 0x89, 0xf4, 0xe7, 0xc0, 0x5a, 0x94,
0x56, 0xe4, 0x5b, 0xc7, 0x73, 0xa6, 0x57, 0x2c, 0x2e, 0xb7, 0xf1, 0x10, 0xa9, 0x12, 0x7e, 0x0c,
0x1e, 0x61, 0x42, 0x98, 0x64, 0x09, 0xc7, 0x17, 0xcb, 0x98, 0x11, 0xa1, 0xbd, 0x3f, 0x44, 0x9d,
0x6d, 0xfb, 0x19, 0x23, 0xa2, 0xff, 0x8b, 0x09, 0x6a, 0xe1, 0x15, 0xe5, 0xf2, 0xc1, 0x9d, 0xff,
0x02, 0x58, 0xca, 0x0d, 0xfd, 0x7a, 0x67, 0xf4, 0xd1, 0x5e, 0xa3, 0xf4, 0x0b, 0xc5, 0x37, 0xba,
0x4e, 0x29, 0xd2, 0x37, 0xf6, 0x6c, 0xfe, 0x5b, 0xb9, 0x58, 0xf7, 0x72, 0x19, 0x83, 0x96, 0x3a,
0x51, 0xb2, 0xc4, 0xb2, 0x5c, 0xf5, 0xee, 0x3d, 0x7f, 0xa3, 0xbb, 0xbf, 0xed, 0x71, 0xf3, 0xe6,
0xb6, 0x57, 0xf9, 0xf9, 0x9f, 0x9e, 0x81, 0x9a, 0xc5, 0xb5, 0xb1, 0xec, 0x7f, 0x03, 0x5a, 0x1b,
0x21, 0xb0, 0x09, 0xac, 0xf0, 0xf9, 0x24, 0xb2, 0x2b, 0xb0, 0x01, 0xaa, 0xa7, 0xa7, 0x5f, 0xdb,
0x06, 0x04, 0xa0, 0x7e, 0x82, 0xc2, 0x71, 0x14, 0xda, 0x26, 0x6c, 0x81, 0xda, 0x3c, 0x1a, 0xa3,
0xc8, 0xae, 0xc2, 0x0e, 0x00, 0xe1, 0xf3, 0xf0, 0x64, 0x39, 0x0e, 0x82, 0x30, 0xb0, 0x2d, 0x45,
0x9b, 0x8d, 0x17, 0xf3, 0x30, 0xb0, 0x6b, 0x9f, 0xfc, 0x61, 0x80, 0x7a, 0x29, 0xd0, 0x05, 0x8d,
0xc5, 0xf4, 0xab, 0xe9, 0xe9, 0xb7, 0x53, 0xbb, 0xd2, 0x7d, 0xef, 0xe5, 0x2b, 0xef, 0xb0, 0x00,
0x16, 0xfc, 0x9c, 0x27, 0x2f, 0xb8, 0xc2, 0x8b, 0xd7, 0x03, 0xdb, 0xd8, 0xc5, 0x4f, 0x32, 0x8a,
0x25, 0x25, 0x0a, 0x47, 0x8b, 0xe9, 0x74, 0x32, 0x7d, 0x66, 0x9b, 0xbb, 0x38, 0xca, 0x39, 0x67,
0x3c, 0x56, 0xf8, 0x3c, 0x3a, 0x9d, 0xcd, 0xc2, 0xc0, 0xae, 0xee, 0xe2, 0x73, 0x99, 0xa4, 0x29,
0x25, 0xf0, 0xc3, 0x8d, 0x2c, 0xab, 0x6b, 0xbf, 0x7c, 0xe5, 0x1d, 0x14, 0xf0, 0x0c, 0xe7, 0x82,
0x92, 0x6e, 0xe7, 0xa7, 0x5f, 0xdd, 0xca, 0x9f, 0xbf, 0xb9, 0xa5, 0xda, 0x63, 0xe7, 0xe6, 0xb5,
0x5b, 0xf9, 0xfb, 0xb5, 0x5b, 0xf9, 0x71, 0xed, 0x1a, 0x37, 0x6b, 0xd7, 0xf8, 0x6b, 0xed, 0x1a,
0xff, 0xae, 0x5d, 0xe3, 0xac, 0xae, 0xdd, 0x7c, 0xfa, 0x7f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x48,
0xcc, 0xfd, 0x9a, 0x96, 0x05, 0x00, 0x00,
}

7
api/types/task/task.proto
View File

@ -23,6 +23,10 @@ message Task {
uint32 pid = 3;
Status status = 4;
google.protobuf.Any spec = 5;
string stdin = 6;
string stdout = 7;
string stderr = 8;
bool terminal = 9;
}
message Process {
@ -35,6 +39,9 @@ message Process {
uint32 exit_status = 7;
Status status = 8;
google.protobuf.Any runtime_data = 9;
string stdin = 10;
string stdout = 11;
string stderr = 12;
}
message User {

35
container.go
View File

@ -3,6 +3,7 @@ package containerd
import (
"context"
"encoding/json"
"path/filepath"
"github.com/containerd/containerd/api/services/containers"
"github.com/containerd/containerd/api/services/execution"
@ -16,7 +17,7 @@ type Container interface {
NewTask(context.Context, IOCreation) (Task, error)
Spec() (*specs.Spec, error)
Task() Task
LoadTask(context.Context, IOCreation) (Task, error)
LoadTask(context.Context, IOAttach) (Task, error)
}
func containerFromProto(client *Client, c containers.Container) *container {
@ -110,17 +111,28 @@ func (c *container) NewTask(ctx context.Context, ioCreate IOCreation) (Task, err
return t, nil
}
func (c *container) LoadTask(ctx context.Context, ioCreate IOCreation) (Task, error) {
i, err := ioCreate()
if err != nil {
return nil, err
}
func (c *container) LoadTask(ctx context.Context, ioAttach IOAttach) (Task, error) {
response, err := c.client.TaskService().Info(ctx, &execution.InfoRequest{
ContainerID: c.c.ID,
})
if err != nil {
return nil, err
}
// get the existing fifo paths from the task information stored by the daemon
paths := &FifoSet{
Dir: getFifoDir([]string{
response.Task.Stdin,
response.Task.Stdout,
response.Task.Stderr,
}),
In: response.Task.Stdin,
Out: response.Task.Stdout,
Err: response.Task.Stderr,
}
i, err := ioAttach(paths)
if err != nil {
return nil, err
}
t := &task{
client: c.client,
io: i,
@ -130,3 +142,14 @@ func (c *container) LoadTask(ctx context.Context, ioCreate IOCreation) (Task, er
c.task = t
return t, nil
}
// getFifoDir looks for any non-empty path for a stdio fifo
// and returns the dir for where it is located
func getFifoDir(paths []string) string {
for _, p := range paths {
if p != "" {
return filepath.Dir(p)
}
}
return ""
}

10
container_test.go
View File

@ -502,13 +502,7 @@ func TestContainerAttach(t *testing.T) {
wg.Done()
}()
// TODO: return fifo information from shim based on task/process
dir, err := ioutil.TempDir("", "attach")
if err != nil {
t.Error(err)
return
}
task, err := container.NewTask(ctx, WithIO(r, ow, ioutil.Discard, dir))
task, err := container.NewTask(ctx, NewIO(r, ow, ioutil.Discard))
if err != nil {
t.Error(err)
return
@ -546,7 +540,7 @@ func TestContainerAttach(t *testing.T) {
t.Error(err)
return
}
if task, err = container.LoadTask(ctx, WithIO(r, ow, ioutil.Discard, dir)); err != nil {
if task, err = container.LoadTask(ctx, WithAttach(r, ow, ioutil.Discard)); err != nil {
t.Error(err)
return
}

25
io.go
View File

@ -1,6 +1,7 @@
package containerd
import (
"fmt"
"io"
"io/ioutil"
"os"
@ -26,6 +27,8 @@ func (i *IO) Close() error {
type IOCreation func() (*IO, error)
type IOAttach func(*FifoSet) (*IO, error)
func NewIO(stdin io.Reader, stdout, stderr io.Writer) IOCreation {
return func() (*IO, error) {
paths, err := NewFifos()
@ -52,11 +55,10 @@ func NewIO(stdin io.Reader, stdout, stderr io.Writer) IOCreation {
}
}
func WithIO(stdin io.Reader, stdout, stderr io.Writer, dir string) IOCreation {
return func() (*IO, error) {
paths, err := WithFifos(dir)
if err != nil {
return nil, err
func WithAttach(stdin io.Reader, stdout, stderr io.Writer) IOAttach {
return func(paths *FifoSet) (*IO, error) {
if paths == nil {
return nil, fmt.Errorf("cannot attach to existing fifos")
}
i := &IO{
Terminal: false,
@ -121,19 +123,6 @@ func NewFifos() (*FifoSet, error) {
}, nil
}
// WithFifos returns existing or creates new fifos inside an existing dir
func WithFifos(dir string) (*FifoSet, error) {
if err := os.MkdirAll(dir, 0700); err != nil {
return nil, err
}
return &FifoSet{
Dir: dir,
In: filepath.Join(dir, "stdin"),
Out: filepath.Join(dir, "stdout"),
Err: filepath.Join(dir, "stderr"),
}, nil
}
type FifoSet struct {
// Dir is the directory holding the task fifos
Dir string

13
linux/shim/exec.go
View File

@ -35,12 +35,21 @@ type execProcess struct {
stdin io.Closer
parent *initProcess
stdinPath string
stdoutPath string
stderrPath string
terminal bool
}
func newExecProcess(context context.Context, path string, r *shimapi.ExecRequest, parent *initProcess, id int) (process, error) {
e := &execProcess{
id: id,
parent: parent,
id: id,
parent: parent,
stdinPath: r.Stdin,
stdoutPath: r.Stdout,
stderrPath: r.Stderr,
terminal: r.Terminal,
}
var (
err error

18
linux/shim/init.go
View File

@ -30,7 +30,8 @@ type initProcess struct {
// the right order when invoked in separate go routines.
// This is the case within the shim implementation as it makes use of
// the reaper interface.
mu sync.Mutex
mu sync.Mutex
id string
bundle string
console console.Console
@ -41,6 +42,11 @@ type initProcess struct {
pid int
closers []io.Closer
stdin io.Closer
stdinPath string
stdoutPath string
stderrPath string
terminal bool
}
func newInitProcess(context context.Context, path string, r *shimapi.CreateRequest) (*initProcess, error) {
@ -61,9 +67,13 @@ func newInitProcess(context context.Context, path string, r *shimapi.CreateReque
PdeathSignal: syscall.SIGKILL,
}
p := &initProcess{
id: r.ID,
bundle: r.Bundle,
runc: runtime,
id: r.ID,
bundle: r.Bundle,
runc: runtime,
stdinPath: r.Stdin,
stdoutPath: r.Stdout,
stderrPath: r.Stderr,
terminal: r.Terminal,
}
var (
err error

16
linux/shim/service.go
View File

@ -192,6 +192,9 @@ func (s *Service) State(ctx context.Context, r *shimapi.StateRequest) (*shimapi.
Pid: uint32(s.initProcess.Pid()),
Status: status,
Processes: []*task.Process{},
Stdin: s.initProcess.stdinPath,
Stdout: s.initProcess.stdoutPath,
Stderr: s.initProcess.stderrPath,
}
s.mu.Lock()
defer s.mu.Unlock()
@ -203,10 +206,16 @@ func (s *Service) State(ctx context.Context, r *shimapi.StateRequest) (*shimapi.
}
status = task.StatusStopped
}
o.Processes = append(o.Processes, &task.Process{
pp := &task.Process{
Pid: uint32(p.Pid()),
Status: status,
})
}
if ep, ok := p.(*execProcess); ok {
pp.Stdin = ep.stdinPath
pp.Stdout = ep.stdoutPath
pp.Stderr = ep.stderrPath
}
o.Processes = append(o.Processes, pp)
}
return o, nil
}
@ -270,7 +279,6 @@ func (s *Service) Processes(ctx context.Context, r *shimapi.ProcessesRequest) (*
if err != nil {
return nil, err
}
ps := []*task.Process{}
for _, pid := range pids {
ps = append(ps, &task.Process{
@ -280,9 +288,7 @@ func (s *Service) Processes(ctx context.Context, r *shimapi.ProcessesRequest) (*
resp := &shimapi.ProcessesResponse{
Processes: ps,
}
return resp, nil
}
func (s *Service) CloseStdin(ctx context.Context, r *shimapi.CloseStdinRequest) (*google_protobuf.Empty, error) {

29
linux/task.go
View File

@ -12,19 +12,6 @@ import (
specs "github.com/opencontainers/runtime-spec/specs-go"
)
type State struct {
pid uint32
status plugin.Status
}
func (s State) Pid() uint32 {
return s.pid
}
func (s State) Status() plugin.Status {
return s.status
}
type Task struct {
containerID string
spec []byte
@ -56,7 +43,7 @@ func (c *Task) Start(ctx context.Context) error {
func (c *Task) State(ctx context.Context) (plugin.State, error) {
response, err := c.shim.State(ctx, &shim.StateRequest{})
if err != nil {
return nil, err
return plugin.State{}, err
}
var status plugin.Status
switch response.Status {
@ -70,9 +57,13 @@ func (c *Task) State(ctx context.Context) (plugin.State, error) {
status = plugin.PausedStatus
// TODO: containerd.DeletedStatus
}
return &State{
pid: response.Pid,
status: status,
return plugin.State{
Pid: response.Pid,
Status: status,
Stdin: response.Stdin,
Stdout: response.Stdout,
Stderr: response.Stderr,
Terminal: response.Terminal,
}, nil
}
@ -181,8 +172,8 @@ func (p *Process) State(ctx context.Context) (plugin.State, error) {
// use the container status for the status of the process
state, err := p.c.State(ctx)
if err != nil {
return nil, err
return state, err
}
state.(*State).pid = uint32(p.pid)
state.Pid = uint32(p.pid)
return state, nil
}

2
metrics/cgroups/cgroups.go
View File

@ -51,7 +51,7 @@ func (m *cgroupsMonitor) Monitor(c plugin.Task) error {
if err != nil {
return err
}
cg, err := cgroups.Load(cgroups.V1, cgroups.PidPath(int(state.Pid())))
cg, err := cgroups.Load(cgroups.V1, cgroups.PidPath(int(state.Pid)))
if err != nil {
return err
}

10
plugin/container.go
View File

@ -71,9 +71,13 @@ const (
PausedStatus
)
type State interface {
type State struct {
// Status is the current status of the container
Status() Status
Status Status
// Pid is the main process id for the container
Pid() uint32
Pid uint32
Stdin string
Stdout string
Stderr string
Terminal bool
}

14
services/execution/service.go
View File

@ -164,7 +164,7 @@ func (s *Service) Create(ctx context.Context, r *api.CreateRequest) (*api.Create
}
return &api.CreateResponse{
ContainerID: r.ContainerID,
Pid: state.Pid(),
Pid: state.Pid,
}, nil
}
@ -208,7 +208,7 @@ func taskFromContainerd(ctx context.Context, c plugin.Task) (*task.Task, error)
}
var status task.Status
switch state.Status() {
switch state.Status {
case plugin.CreatedStatus:
status = task.StatusCreated
case plugin.RunningStatus:
@ -218,17 +218,21 @@ func taskFromContainerd(ctx context.Context, c plugin.Task) (*task.Task, error)
case plugin.PausedStatus:
status = task.StatusPaused
default:
log.G(ctx).WithField("status", state.Status()).Warn("unknown status")
log.G(ctx).WithField("status", state.Status).Warn("unknown status")
}
return &task.Task{
ID: c.Info().ID,
ContainerID: c.Info().ContainerID,
Pid: state.Pid(),
Pid: state.Pid,
Status: status,
Spec: &protobuf.Any{
TypeUrl: specs.Version,
Value: c.Info().Spec,
},
Stdin: state.Stdin,
Stdout: state.Stdout,
Stderr: state.Stderr,
Terminal: state.Terminal,
}, nil
}
@ -359,7 +363,7 @@ func (s *Service) Exec(ctx context.Context, r *api.ExecRequest) (*api.ExecRespon
return nil, err
}
return &api.ExecResponse{
Pid: state.Pid(),
Pid: state.Pid,
}, nil
}

5
windows/container.go
View File

@ -116,7 +116,10 @@ func (c *container) Resume(ctx context.Context) error {
}
func (c *container) State(ctx context.Context) (plugin.State, error) {
return c, nil
return plugin.State{
Pid: c.Pid(),
Status: c.Status(),
}, nil
}
func (c *container) Kill(ctx context.Context, signal uint32, pid uint32, all bool) error {

5
windows/process.go
View File

@ -15,7 +15,10 @@ type process struct {
}
func (p *process) State(ctx context.Context) (plugin.State, error) {
return p, nil
return plugin.State{
Pid: p.Pid(),
Status: p.Status(),
}, nil
}
func (p *process) Kill(ctx context.Context, sig uint32, all bool) error {