diff --git a/api/services/shim/shim.pb.go b/api/services/shim/shim.pb.go index d034825be..667e0e862 100644 --- a/api/services/shim/shim.pb.go +++ b/api/services/shim/shim.pb.go @@ -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, } diff --git a/api/services/shim/shim.proto b/api/services/shim/shim.proto index 94f859dfd..b6aefba20 100644 --- a/api/services/shim/shim.proto +++ b/api/services/shim/shim.proto @@ -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 { diff --git a/api/types/task/task.pb.go b/api/types/task/task.pb.go index cb8775ef4..be43ffd57 100644 --- a/api/types/task/task.pb.go +++ b/api/types/task/task.pb.go @@ -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, } diff --git a/api/types/task/task.proto b/api/types/task/task.proto index cce329f8e..e7563200e 100644 --- a/api/types/task/task.proto +++ b/api/types/task/task.proto @@ -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 { diff --git a/client.go b/client.go index 2047c373e..eacb1024b 100644 --- a/client.go +++ b/client.go @@ -203,6 +203,16 @@ func (c *Client) NewContainer(ctx context.Context, id string, spec *specs.Spec, return containerFromProto(c, r.Container), nil } +func (c *Client) LoadContainer(ctx context.Context, id string) (Container, error) { + response, err := c.ContainerService().Get(ctx, &containers.GetContainerRequest{ + ID: id, + }) + if err != nil { + return nil, err + } + return containerFromProto(c, response.Container), nil +} + type RemoteOpts func(*Client, *RemoteContext) error // RemoteContext is used to configure object resolutions and transfers with diff --git a/container.go b/container.go index 7b9bffd8d..7a587b647 100644 --- a/container.go +++ b/container.go @@ -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,6 +17,7 @@ type Container interface { NewTask(context.Context, IOCreation) (Task, error) Spec() (*specs.Spec, error) Task() Task + LoadTask(context.Context, IOAttach) (Task, error) } func containerFromProto(client *Client, c containers.Container) *container { @@ -108,3 +110,47 @@ func (c *container) NewTask(ctx context.Context, ioCreate IOCreation) (Task, err c.task = t return t, nil } + +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, + Terminal: response.Task.Terminal, + } + i, err := ioAttach(paths) + if err != nil { + return nil, err + } + t := &task{ + client: c.client, + io: i, + containerID: response.Task.ContainerID, + pid: response.Task.Pid, + } + 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 "" +} diff --git a/container_test.go b/container_test.go index 00b9c43b0..644334ad9 100644 --- a/container_test.go +++ b/container_test.go @@ -3,12 +3,18 @@ package containerd import ( "bytes" "context" + "fmt" + "io" + "io/ioutil" + "os" + "sync" "syscall" "testing" ) func empty() IOCreation { - return BufferedIO(bytes.NewBuffer(nil), bytes.NewBuffer(nil), bytes.NewBuffer(nil)) + null := ioutil.Discard + return NewIO(bytes.NewBuffer(nil), null, null) } func TestContainerList(t *testing.T) { @@ -167,7 +173,7 @@ func TestContainerOutput(t *testing.T) { defer container.Delete(ctx) stdout := bytes.NewBuffer(nil) - task, err := container.NewTask(ctx, BufferedIO(bytes.NewBuffer(nil), stdout, bytes.NewBuffer(nil))) + task, err := container.NewTask(ctx, NewIO(bytes.NewBuffer(nil), stdout, bytes.NewBuffer(nil))) if err != nil { t.Error(err) return @@ -360,3 +366,208 @@ func TestContainerProcesses(t *testing.T) { } <-statusC } + +func TestContainerCloseStdin(t *testing.T) { + if testing.Short() { + t.Skip() + } + client, err := New(address) + if err != nil { + t.Fatal(err) + } + defer client.Close() + + var ( + ctx = context.Background() + id = "ContainerCloseStdin" + ) + image, err := client.GetImage(ctx, testImage) + if err != nil { + t.Error(err) + return + } + spec, err := GenerateSpec(WithImageConfig(ctx, image), WithProcessArgs("cat")) + if err != nil { + t.Error(err) + return + } + container, err := client.NewContainer(ctx, id, spec, WithImage(image), WithNewRootFS(id, image)) + if err != nil { + t.Error(err) + return + } + defer container.Delete(ctx) + + const expected = "hello\n" + stdout := bytes.NewBuffer(nil) + + r, w, err := os.Pipe() + if err != nil { + t.Error(err) + return + } + + task, err := container.NewTask(ctx, NewIO(r, stdout, ioutil.Discard)) + 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 := fmt.Fprint(w, expected); err != nil { + t.Error(err) + } + w.Close() + if err := task.CloseStdin(ctx); err != nil { + t.Error(err) + } + + <-statusC + + if _, err := task.Delete(ctx); err != nil { + t.Error(err) + } + + output := stdout.String() + + if output != expected { + t.Errorf("expected output %q but received %q", expected, output) + } +} + +func TestContainerAttach(t *testing.T) { + if testing.Short() { + t.Skip() + } + client, err := New(address) + if err != nil { + t.Fatal(err) + } + defer client.Close() + + var ( + ctx = context.Background() + id = "ContainerAttach" + ) + image, err := client.GetImage(ctx, testImage) + if err != nil { + t.Error(err) + return + } + spec, err := GenerateSpec(WithImageConfig(ctx, image), WithProcessArgs("cat")) + if err != nil { + t.Error(err) + return + } + container, err := client.NewContainer(ctx, id, spec, WithImage(image), WithNewRootFS(id, image)) + if err != nil { + t.Error(err) + return + } + defer container.Delete(ctx) + + expected := "hello\n" + stdout := bytes.NewBuffer(nil) + + r, w, err := os.Pipe() + if err != nil { + t.Error(err) + return + } + or, ow, err := os.Pipe() + if err != nil { + t.Error(err) + return + } + + wg := &sync.WaitGroup{} + + wg.Add(1) + go func() { + io.Copy(stdout, or) + wg.Done() + }() + + task, err := container.NewTask(ctx, NewIO(r, ow, ioutil.Discard)) + if err != nil { + t.Error(err) + return + } + defer task.Delete(ctx) + originalIO := task.IO() + + 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 := fmt.Fprint(w, expected); err != nil { + t.Error(err) + } + w.Close() + + // load the container and re-load the task + if container, err = client.LoadContainer(ctx, id); err != nil { + t.Error(err) + return + } + + // create new IO for the loaded task + if r, w, err = os.Pipe(); err != nil { + t.Error(err) + return + } + if task, err = container.LoadTask(ctx, WithAttach(r, ow, ioutil.Discard)); err != nil { + t.Error(err) + return + } + + if _, err := fmt.Fprint(w, expected); err != nil { + t.Error(err) + } + w.Close() + + if err := task.CloseStdin(ctx); err != nil { + t.Error(err) + } + + <-statusC + + originalIO.Close() + if _, err := task.Delete(ctx); err != nil { + t.Error(err) + } + ow.Close() + + wg.Wait() + output := stdout.String() + + // we wrote the same thing after attach + expected = expected + expected + if output != expected { + t.Errorf("expected output %q but received %q", expected, output) + } +} diff --git a/io.go b/io.go index ea3325967..e3c56d909 100644 --- a/io.go +++ b/io.go @@ -1,7 +1,7 @@ package containerd import ( - "bytes" + "fmt" "io" "io/ioutil" "os" @@ -27,25 +27,56 @@ func (i *IO) Close() error { type IOCreation func() (*IO, error) -// BufferedIO returns IO that will be logged to an in memory buffer -func BufferedIO(stdin, stdout, stderr *bytes.Buffer) IOCreation { +type IOAttach func(*FifoSet) (*IO, error) + +func NewIO(stdin io.Reader, stdout, stderr io.Writer) IOCreation { + return NewIOWithTerminal(stdin, stdout, stderr, false) +} + +func NewIOWithTerminal(stdin io.Reader, stdout, stderr io.Writer, terminal bool) IOCreation { return func() (*IO, error) { - paths, err := fifoPaths() + paths, err := NewFifos() if err != nil { return nil, err } i := &IO{ - Terminal: false, - Stdout: paths.out, - Stderr: paths.err, - Stdin: paths.in, + Terminal: terminal, + Stdout: paths.Out, + Stderr: paths.Err, + Stdin: paths.In, } set := &ioSet{ in: stdin, out: stdout, err: stderr, } - closer, err := copyIO(paths, set, false) + closer, err := copyIO(paths, set, i.Terminal) + if err != nil { + return nil, err + } + i.closer = closer + return i, nil + } + +} + +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: paths.Terminal, + Stdout: paths.Out, + Stderr: paths.Err, + Stdin: paths.In, + } + set := &ioSet{ + in: stdin, + out: stdout, + err: stderr, + } + closer, err := copyIO(paths, set, i.Terminal) if err != nil { return nil, err } @@ -57,29 +88,16 @@ func BufferedIO(stdin, stdout, stderr *bytes.Buffer) IOCreation { // Stdio returns an IO implementation to be used for a task // that outputs the container's IO as the current processes Stdio func Stdio() (*IO, error) { - paths, err := fifoPaths() - if err != nil { - return nil, err - } - set := &ioSet{ - in: os.Stdin, - out: os.Stdout, - err: os.Stderr, - } - closer, err := copyIO(paths, set, false) - if err != nil { - return nil, err - } - return &IO{ - Terminal: false, - Stdin: paths.in, - Stdout: paths.out, - Stderr: paths.err, - closer: closer, - }, nil + return NewIO(os.Stdin, os.Stdout, os.Stderr)() } -func fifoPaths() (*fifoSet, error) { +// StdioTerminal will setup the IO for the task to use a terminal +func StdioTerminal() (*IO, error) { + return NewIOWithTerminal(os.Stdin, os.Stdout, os.Stderr, true)() +} + +// NewFifos returns a new set of fifos for the task +func NewFifos() (*FifoSet, error) { root := filepath.Join(os.TempDir(), "containerd") if err := os.MkdirAll(root, 0700); err != nil { return nil, err @@ -88,18 +106,19 @@ func fifoPaths() (*fifoSet, error) { if err != nil { return nil, err } - return &fifoSet{ - dir: dir, - in: filepath.Join(dir, "stdin"), - out: filepath.Join(dir, "stdout"), - err: filepath.Join(dir, "stderr"), + 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 - in, out, err string +type FifoSet struct { + // Dir is the directory holding the task fifos + Dir string + In, Out, Err string + Terminal bool } type ioSet struct { diff --git a/io_unix.go b/io_unix.go index a243c3a52..5c0cf0091 100644 --- a/io_unix.go +++ b/io_unix.go @@ -11,14 +11,14 @@ import ( "github.com/containerd/fifo" ) -func copyIO(fifos *fifoSet, ioset *ioSet, tty bool) (closer io.Closer, err error) { +func copyIO(fifos *FifoSet, ioset *ioSet, tty bool) (closer io.Closer, err error) { var ( f io.ReadWriteCloser ctx = context.Background() wg = &sync.WaitGroup{} ) - if f, err = fifo.OpenFifo(ctx, fifos.in, syscall.O_WRONLY|syscall.O_CREAT|syscall.O_NONBLOCK, 0700); err != nil { + if f, err = fifo.OpenFifo(ctx, fifos.In, syscall.O_WRONLY|syscall.O_CREAT|syscall.O_NONBLOCK, 0700); err != nil { return nil, err } defer func(c io.Closer) { @@ -31,7 +31,7 @@ func copyIO(fifos *fifoSet, ioset *ioSet, tty bool) (closer io.Closer, err error w.Close() }(f) - if f, err = fifo.OpenFifo(ctx, fifos.out, syscall.O_RDONLY|syscall.O_CREAT|syscall.O_NONBLOCK, 0700); err != nil { + if f, err = fifo.OpenFifo(ctx, fifos.Out, syscall.O_RDONLY|syscall.O_CREAT|syscall.O_NONBLOCK, 0700); err != nil { return nil, err } defer func(c io.Closer) { @@ -46,7 +46,7 @@ func copyIO(fifos *fifoSet, ioset *ioSet, tty bool) (closer io.Closer, err error wg.Done() }(f) - if f, err = fifo.OpenFifo(ctx, fifos.err, syscall.O_RDONLY|syscall.O_CREAT|syscall.O_NONBLOCK, 0700); err != nil { + if f, err = fifo.OpenFifo(ctx, fifos.Err, syscall.O_RDONLY|syscall.O_CREAT|syscall.O_NONBLOCK, 0700); err != nil { return nil, err } defer func(c io.Closer) { @@ -66,6 +66,6 @@ func copyIO(fifos *fifoSet, ioset *ioSet, tty bool) (closer io.Closer, err error return &wgCloser{ wg: wg, - dir: fifos.dir, + dir: fifos.Dir, }, nil } diff --git a/io_windows.go b/io_windows.go index 4aa2ed5aa..2fb97566c 100644 --- a/io_windows.go +++ b/io_windows.go @@ -10,13 +10,13 @@ import ( "github.com/pkg/errors" ) -func copyIO(fifos *fifoSet, ioset *ioSet, tty bool) (closer io.Closer, err error) { +func copyIO(fifos *FifoSet, ioset *ioSet, tty bool) (closer io.Closer, err error) { var wg sync.WaitGroup - if fifos.in != "" { - l, err := winio.ListenPipe(fifos.in, nil) + if fifos.In != "" { + l, err := winio.ListenPipe(fifos.In, nil) if err != nil { - return nil, errors.Wrapf(err, "failed to create stdin pipe %s", fifos.in) + return nil, errors.Wrapf(err, "failed to create stdin pipe %s", fifos.In) } defer func(l net.Listener) { if err != nil { @@ -27,7 +27,7 @@ func copyIO(fifos *fifoSet, ioset *ioSet, tty bool) (closer io.Closer, err error go func() { c, err := l.Accept() if err != nil { - log.L.WithError(err).Errorf("failed to accept stdin connection on %s", fifos.in) + log.L.WithError(err).Errorf("failed to accept stdin connection on %s", fifos.In) return } io.Copy(c, ioset.in) @@ -36,10 +36,10 @@ func copyIO(fifos *fifoSet, ioset *ioSet, tty bool) (closer io.Closer, err error }() } - if fifos.out != "" { - l, err := winio.ListenPipe(fifos.out, nil) + if fifos.Out != "" { + l, err := winio.ListenPipe(fifos.Out, nil) if err != nil { - return nil, errors.Wrapf(err, "failed to create stdin pipe %s", fifos.out) + return nil, errors.Wrapf(err, "failed to create stdin pipe %s", fifos.Out) } defer func(l net.Listener) { if err != nil { @@ -52,7 +52,7 @@ func copyIO(fifos *fifoSet, ioset *ioSet, tty bool) (closer io.Closer, err error defer wg.Done() c, err := l.Accept() if err != nil { - log.L.WithError(err).Errorf("failed to accept stdout connection on %s", fifos.out) + log.L.WithError(err).Errorf("failed to accept stdout connection on %s", fifos.Out) return } io.Copy(ioset.out, c) @@ -61,10 +61,10 @@ func copyIO(fifos *fifoSet, ioset *ioSet, tty bool) (closer io.Closer, err error }() } - if !tty && fifos.err != "" { - l, err := winio.ListenPipe(fifos.err, nil) + if !tty && fifos.Err != "" { + l, err := winio.ListenPipe(fifos.Err, nil) if err != nil { - return nil, errors.Wrapf(err, "failed to create stderr pipe %s", fifos.err) + return nil, errors.Wrapf(err, "failed to create stderr pipe %s", fifos.Err) } defer func(l net.Listener) { if err != nil { @@ -77,7 +77,7 @@ func copyIO(fifos *fifoSet, ioset *ioSet, tty bool) (closer io.Closer, err error defer wg.Done() c, err := l.Accept() if err != nil { - log.L.WithError(err).Errorf("failed to accept stderr connection on %s", fifos.err) + log.L.WithError(err).Errorf("failed to accept stderr connection on %s", fifos.Err) return } io.Copy(ioset.err, c) @@ -88,6 +88,6 @@ func copyIO(fifos *fifoSet, ioset *ioSet, tty bool) (closer io.Closer, err error return &wgCloser{ wg: &wg, - dir: fifos.dir, + dir: fifos.Dir, }, nil } diff --git a/linux/shim/exec.go b/linux/shim/exec.go index 72703677b..39e2b3aeb 100644 --- a/linux/shim/exec.go +++ b/linux/shim/exec.go @@ -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 diff --git a/linux/shim/init.go b/linux/shim/init.go index 0bf538a71..1f8ed3047 100644 --- a/linux/shim/init.go +++ b/linux/shim/init.go @@ -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 diff --git a/linux/shim/service.go b/linux/shim/service.go index cb03d23fb..3983f6f7a 100644 --- a/linux/shim/service.go +++ b/linux/shim/service.go @@ -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) { diff --git a/linux/task.go b/linux/task.go index dd0de51f6..1a04033a4 100644 --- a/linux/task.go +++ b/linux/task.go @@ -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 } diff --git a/metrics/cgroups/cgroups.go b/metrics/cgroups/cgroups.go index ab3009893..1fb3ea373 100644 --- a/metrics/cgroups/cgroups.go +++ b/metrics/cgroups/cgroups.go @@ -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 } diff --git a/plugin/container.go b/plugin/container.go index 2d2145a5a..5c013623c 100644 --- a/plugin/container.go +++ b/plugin/container.go @@ -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 } diff --git a/process.go b/process.go index 6a1fb552c..f98304fee 100644 --- a/process.go +++ b/process.go @@ -88,3 +88,25 @@ func (p *process) Wait(ctx context.Context) (uint32, error) { } } } + +func (p *process) CloseStdin(ctx context.Context) error { + _, err := p.task.client.TaskService().CloseStdin(ctx, &execution.CloseStdinRequest{ + ContainerID: p.task.containerID, + Pid: p.pid, + }) + return err +} + +func (p *process) IO() *IO { + return p.io +} + +func (p *process) Resize(ctx context.Context, w, h uint32) error { + _, err := p.task.client.TaskService().Pty(ctx, &execution.PtyRequest{ + ContainerID: p.task.containerID, + Width: w, + Height: h, + Pid: p.pid, + }) + return err +} diff --git a/services/execution/service.go b/services/execution/service.go index e944dd412..dacad40de 100644 --- a/services/execution/service.go +++ b/services/execution/service.go @@ -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 } diff --git a/task.go b/task.go index ba5489a64..ead1ea6c0 100644 --- a/task.go +++ b/task.go @@ -32,6 +32,9 @@ type Task interface { Wait(context.Context) (uint32, error) Exec(context.Context, *specs.Process, IOCreation) (Process, error) Processes(context.Context) ([]uint32, error) + CloseStdin(context.Context) error + Resize(ctx context.Context, w, h uint32) error + IO() *IO } type Process interface { @@ -39,6 +42,9 @@ type Process interface { Start(context.Context) error Kill(context.Context, syscall.Signal) error Wait(context.Context) (uint32, error) + CloseStdin(context.Context) error + Resize(ctx context.Context, w, h uint32) error + IO() *IO } var _ = (Task)(&task{}) @@ -158,3 +164,25 @@ func (t *task) Processes(ctx context.Context) ([]uint32, error) { } return out, nil } + +func (t *task) CloseStdin(ctx context.Context) error { + _, err := t.client.TaskService().CloseStdin(ctx, &execution.CloseStdinRequest{ + ContainerID: t.containerID, + Pid: t.pid, + }) + return err +} + +func (t *task) IO() *IO { + return t.io +} + +func (t *task) Resize(ctx context.Context, w, h uint32) error { + _, err := t.client.TaskService().Pty(ctx, &execution.PtyRequest{ + ContainerID: t.containerID, + Width: w, + Height: h, + Pid: t.pid, + }) + return err +} diff --git a/windows/container.go b/windows/container.go index 0afed30e0..06232e73c 100644 --- a/windows/container.go +++ b/windows/container.go @@ -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 { diff --git a/windows/process.go b/windows/process.go index 438eea56d..adf9b7a8d 100644 --- a/windows/process.go +++ b/windows/process.go @@ -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 {