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

PsRequest/PsResponse -> ProcessesRequest/ProcessesResponse; added Any to types.Process

Browse Source 
Signed-off-by: Evan Hazlett <ejhazlett@gmail.com>
This commit is contained in:
Evan Hazlett 2017-05-16 16:14:52 -04:00
parent ef158f8b5e
commit 395d21018f
6 changed files with 232 additions and 352 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

388
api/services/execution/execution.pb.go
View File

@ -25,9 +25,8 @@
CloseStdinRequest
PauseRequest
ResumeRequest
PsRequest
Ps
PsResponse
ProcessesRequest
ProcessesResponse
*/
package execution
@ -322,30 +321,21 @@ func (m *ResumeRequest) Reset() { *m = ResumeRequest{} }
func (*ResumeRequest) ProtoMessage() {}
func (*ResumeRequest) Descriptor() ([]byte, []int) { return fileDescriptorExecution, []int{15} }
type PsRequest struct {
type ProcessesRequest struct {
ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
}
func (m *PsRequest) Reset() { *m = PsRequest{} }
func (*PsRequest) ProtoMessage() {}
func (*PsRequest) Descriptor() ([]byte, []int) { return fileDescriptorExecution, []int{16} }
func (m *ProcessesRequest) Reset() { *m = ProcessesRequest{} }
func (*ProcessesRequest) ProtoMessage() {}
func (*ProcessesRequest) Descriptor() ([]byte, []int) { return fileDescriptorExecution, []int{16} }
type Ps struct {
Pid uint32 `protobuf:"varint,1,opt,name=pid,proto3" json:"pid,omitempty"`
RuntimeData *google_protobuf1.Any `protobuf:"bytes,2,opt,name=runtime_data,json=runtimeData" json:"runtime_data,omitempty"`
type ProcessesResponse struct {
Processes []*containerd_v1_types1.Process `protobuf:"bytes,1,rep,name=processes" json:"processes,omitempty"`
}
func (m *Ps) Reset() { *m = Ps{} }
func (*Ps) ProtoMessage() {}
func (*Ps) Descriptor() ([]byte, []int) { return fileDescriptorExecution, []int{17} }
type PsResponse struct {
Ps []*Ps `protobuf:"bytes,1,rep,name=ps" json:"ps,omitempty"`
}
func (m *PsResponse) Reset() { *m = PsResponse{} }
func (*PsResponse) ProtoMessage() {}
func (*PsResponse) Descriptor() ([]byte, []int) { return fileDescriptorExecution, []int{18} }
func (m *ProcessesResponse) Reset() { *m = ProcessesResponse{} }
func (*ProcessesResponse) ProtoMessage() {}
func (*ProcessesResponse) Descriptor() ([]byte, []int) { return fileDescriptorExecution, []int{17} }
func init() {
proto.RegisterType((*CreateRequest)(nil), "containerd.v1.services.CreateRequest")
@ -364,9 +354,8 @@ func init() {
proto.RegisterType((*CloseStdinRequest)(nil), "containerd.v1.services.CloseStdinRequest")
proto.RegisterType((*PauseRequest)(nil), "containerd.v1.services.PauseRequest")
proto.RegisterType((*ResumeRequest)(nil), "containerd.v1.services.ResumeRequest")
proto.RegisterType((*PsRequest)(nil), "containerd.v1.services.PsRequest")
proto.RegisterType((*Ps)(nil), "containerd.v1.services.Ps")
proto.RegisterType((*PsResponse)(nil), "containerd.v1.services.PsResponse")
proto.RegisterType((*ProcessesRequest)(nil), "containerd.v1.services.ProcessesRequest")
proto.RegisterType((*ProcessesResponse)(nil), "containerd.v1.services.ProcessesResponse")
}
// Reference imports to suppress errors if they are not otherwise used.
@ -392,7 +381,7 @@ type ContainerServiceClient interface {
CloseStdin(ctx context.Context, in *CloseStdinRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
Pause(ctx context.Context, in *PauseRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
Resume(ctx context.Context, in *ResumeRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
Ps(ctx context.Context, in *PsRequest, opts ...grpc.CallOption) (*PsResponse, error)
Processes(ctx context.Context, in *ProcessesRequest, opts ...grpc.CallOption) (*ProcessesResponse, error)
}
type containerServiceClient struct {
@ -534,9 +523,9 @@ func (c *containerServiceClient) Resume(ctx context.Context, in *ResumeRequest,
return out, nil
}
func (c *containerServiceClient) Ps(ctx context.Context, in *PsRequest, opts ...grpc.CallOption) (*PsResponse, error) {
out := new(PsResponse)
err := grpc.Invoke(ctx, "/containerd.v1.services.ContainerService/Ps", in, out, c.cc, opts...)
func (c *containerServiceClient) Processes(ctx context.Context, in *ProcessesRequest, opts ...grpc.CallOption) (*ProcessesResponse, error) {
out := new(ProcessesResponse)
err := grpc.Invoke(ctx, "/containerd.v1.services.ContainerService/Processes", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
@ -558,7 +547,7 @@ type ContainerServiceServer interface {
CloseStdin(context.Context, *CloseStdinRequest) (*google_protobuf.Empty, error)
Pause(context.Context, *PauseRequest) (*google_protobuf.Empty, error)
Resume(context.Context, *ResumeRequest) (*google_protobuf.Empty, error)
Ps(context.Context, *PsRequest) (*PsResponse, error)
Processes(context.Context, *ProcessesRequest) (*ProcessesResponse, error)
}
func RegisterContainerServiceServer(s *grpc.Server, srv ContainerServiceServer) {
@ -784,20 +773,20 @@ func _ContainerService_Resume_Handler(srv interface{}, ctx context.Context, dec
return interceptor(ctx, in, info, handler)
}
func _ContainerService_Ps_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(PsRequest)
func _ContainerService_Processes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ProcessesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ContainerServiceServer).Ps(ctx, in)
return srv.(ContainerServiceServer).Processes(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.v1.services.ContainerService/Ps",
FullMethod: "/containerd.v1.services.ContainerService/Processes",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ContainerServiceServer).Ps(ctx, req.(*PsRequest))
return srv.(ContainerServiceServer).Processes(ctx, req.(*ProcessesRequest))
}
return interceptor(ctx, in, info, handler)
}
@ -851,8 +840,8 @@ var _ContainerService_serviceDesc = grpc.ServiceDesc{
Handler: _ContainerService_Resume_Handler,
},
{
MethodName: "Ps",
Handler: _ContainerService_Ps_Handler,
MethodName: "Processes",
Handler: _ContainerService_Processes_Handler,
},
},
Streams: []grpc.StreamDesc{
@ -1405,7 +1394,7 @@ func (m *ResumeRequest) MarshalTo(dAtA []byte) (int, error) {
return i, nil
}
func (m *PsRequest) Marshal() (dAtA []byte, err error) {
func (m *ProcessesRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
@ -1415,7 +1404,7 @@ func (m *PsRequest) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
func (m *PsRequest) MarshalTo(dAtA []byte) (int, error) {
func (m *ProcessesRequest) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
@ -1429,7 +1418,7 @@ func (m *PsRequest) MarshalTo(dAtA []byte) (int, error) {
return i, nil
}
func (m *Ps) Marshal() (dAtA []byte, err error) {
func (m *ProcessesResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
@ -1439,46 +1428,13 @@ func (m *Ps) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
func (m *Ps) MarshalTo(dAtA []byte) (int, error) {
func (m *ProcessesResponse) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Pid != 0 {
dAtA[i] = 0x8
i++
i = encodeVarintExecution(dAtA, i, uint64(m.Pid))
}
if m.RuntimeData != nil {
dAtA[i] = 0x12
i++
i = encodeVarintExecution(dAtA, i, uint64(m.RuntimeData.Size()))
n5, err := m.RuntimeData.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n5
}
return i, nil
}
func (m *PsResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *PsResponse) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.Ps) > 0 {
for _, msg := range m.Ps {
if len(m.Processes) > 0 {
for _, msg := range m.Processes {
dAtA[i] = 0xa
i++
i = encodeVarintExecution(dAtA, i, uint64(msg.Size()))
@ -1758,7 +1714,7 @@ func (m *ResumeRequest) Size() (n int) {
return n
}
func (m *PsRequest) Size() (n int) {
func (m *ProcessesRequest) Size() (n int) {
var l int
_ = l
l = len(m.ID)
@ -1768,24 +1724,11 @@ func (m *PsRequest) Size() (n int) {
return n
}
func (m *Ps) Size() (n int) {
func (m *ProcessesResponse) Size() (n int) {
var l int
_ = l
if m.Pid != 0 {
n += 1 + sovExecution(uint64(m.Pid))
}
if m.RuntimeData != nil {
l = m.RuntimeData.Size()
n += 1 + l + sovExecution(uint64(l))
}
return n
}
func (m *PsResponse) Size() (n int) {
var l int
_ = l
if len(m.Ps) > 0 {
for _, e := range m.Ps {
if len(m.Processes) > 0 {
for _, e := range m.Processes {
l = e.Size()
n += 1 + l + sovExecution(uint64(l))
}
@ -2005,33 +1948,22 @@ func (this *ResumeRequest) String() string {
}, "")
return s
}
func (this *PsRequest) String() string {
func (this *ProcessesRequest) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&PsRequest{`,
s := strings.Join([]string{`&ProcessesRequest{`,
`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
`}`,
}, "")
return s
}
func (this *Ps) String() string {
func (this *ProcessesResponse) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&Ps{`,
`Pid:` + fmt.Sprintf("%v", this.Pid) + `,`,
`RuntimeData:` + strings.Replace(fmt.Sprintf("%v", this.RuntimeData), "Any", "google_protobuf1.Any", 1) + `,`,
`}`,
}, "")
return s
}
func (this *PsResponse) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&PsResponse{`,
`Ps:` + strings.Replace(fmt.Sprintf("%v", this.Ps), "Ps", "Ps", 1) + `,`,
s := strings.Join([]string{`&ProcessesResponse{`,
`Processes:` + strings.Replace(fmt.Sprintf("%v", this.Processes), "Process", "containerd_v1_types1.Process", 1) + `,`,
`}`,
}, "")
return s
@ -3786,7 +3718,7 @@ func (m *ResumeRequest) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *PsRequest) Unmarshal(dAtA []byte) error {
func (m *ProcessesRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@ -3809,10 +3741,10 @@ func (m *PsRequest) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: PsRequest: wiretype end group for non-group")
return fmt.Errorf("proto: ProcessesRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: PsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
return fmt.Errorf("proto: ProcessesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
@ -3865,7 +3797,7 @@ func (m *PsRequest) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *Ps) Unmarshal(dAtA []byte) error {
func (m *ProcessesResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@ -3888,34 +3820,15 @@ func (m *Ps) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: Ps: wiretype end group for non-group")
return fmt.Errorf("proto: ProcessesResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Ps: illegal tag %d (wire type %d)", fieldNum, wire)
return fmt.Errorf("proto: ProcessesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType)
}
m.Pid = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowExecution
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Pid |= (uint32(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field RuntimeData", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field Processes", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@ -3939,91 +3852,8 @@ func (m *Ps) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.RuntimeData == nil {
m.RuntimeData = &google_protobuf1.Any{}
}
if err := m.RuntimeData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipExecution(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthExecution
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *PsResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowExecution
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: PsResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: PsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Ps", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowExecution
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthExecution
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Ps = append(m.Ps, &Ps{})
if err := m.Ps[len(m.Ps)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
m.Processes = append(m.Processes, &containerd_v1_types1.Process{})
if err := m.Processes[len(m.Processes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
@ -4158,64 +3988,64 @@ func init() {
}
var fileDescriptorExecution = []byte{
// 944 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x55, 0xcd, 0x8e, 0xe3, 0x44,
0x10, 0x1e, 0x3b, 0x89, 0x37, 0x5b, 0x49, 0x96, 0xa5, 0x35, 0x1a, 0x19, 0x23, 0x25, 0xc1, 0xfb,
0x43, 0xe0, 0xe0, 0xc0, 0x70, 0x00, 0x21, 0x40, 0x9a, 0x9f, 0x68, 0x59, 0x0d, 0xcb, 0x06, 0x0f,
0x12, 0xc7, 0xc8, 0x13, 0xf7, 0x64, 0x5a, 0x72, 0x6c, 0xe3, 0x6e, 0x0f, 0x93, 0x1b, 0x88, 0x2b,
0x07, 0x5e, 0x85, 0xb7, 0x98, 0x23, 0x47, 0x4e, 0x0b, 0x9b, 0x27, 0x41, 0xfd, 0xe3, 0xc4, 0xc9,
0x4c, 0x8f, 0x77, 0x2f, 0x51, 0x57, 0xa5, 0xaa, 0xfa, 0xab, 0xea, 0xaf, 0x3e, 0xc3, 0xb3, 0x19,
0x61, 0x17, 0xf9, 0x99, 0x37, 0x4d, 0xe6, 0xc3, 0x69, 0x12, 0xb3, 0x80, 0xc4, 0x38, 0x0b, 0xcb,
0xc7, 0x20, 0x25, 0x43, 0x8a, 0xb3, 0x4b, 0x32, 0xc5, 0x74, 0x88, 0xaf, 0xf0, 0x34, 0x67, 0x24,
0x89, 0xd7, 0x27, 0x2f, 0xcd, 0x12, 0x96, 0xa0, 0xbd, 0x75, 0x8a, 0x77, 0xf9, 0xa9, 0x57, 0x64,
0x38, 0xef, 0xcf, 0x92, 0x64, 0x16, 0xe1, 0xa1, 0x88, 0x3a, 0xcb, 0xcf, 0x87, 0x78, 0x9e, 0xb2,
0x85, 0x4c, 0x72, 0xde, 0xdb, 0xfe, 0x33, 0x88, 0x8b, 0xbf, 0x76, 0x67, 0xc9, 0x2c, 0x11, 0xc7,
0x21, 0x3f, 0x29, 0xef, 0x57, 0x6f, 0x04, 0x97, 0x2d, 0x52, 0x4c, 0x87, 0xf3, 0x24, 0x8f, 0x99,
0xfc, 0x55, 0xd9, 0xc7, 0x6f, 0x91, 0xbd, 0x72, 0xae, 0x4f, 0xaa, 0x4a, 0x6f, 0x1b, 0x34, 0x23,
0x73, 0x4c, 0x59, 0x30, 0x4f, 0x65, 0x80, 0xfb, 0x9b, 0x09, 0x9d, 0xa3, 0x0c, 0x07, 0x0c, 0xfb,
0xf8, 0xe7, 0x1c, 0x53, 0x86, 0xf6, 0xc0, 0x24, 0xa1, 0x6d, 0xf4, 0x8d, 0xc1, 0xfd, 0x43, 0x6b,
0xf9, 0xaa, 0x67, 0x3e, 0x3f, 0xf6, 0x4d, 0x12, 0xa2, 0x01, 0xd4, 0x69, 0x8a, 0xa7, 0xb6, 0xd9,
0x37, 0x06, 0xad, 0xfd, 0x5d, 0x4f, 0x56, 0xf6, 0x8a, 0xca, 0xde, 0x41, 0xbc, 0xf0, 0x45, 0x04,
0xda, 0x07, 0x2b, 0x4b, 0x12, 0x76, 0x4e, 0xed, 0x5a, 0xbf, 0x36, 0x68, 0xed, 0x3b, 0xde, 0xe6,
0xbc, 0x05, 0x68, 0xef, 0x05, 0x6f, 0xd6, 0x57, 0x91, 0xc8, 0x86, 0x7b, 0x59, 0x1e, 0x73, 0x74,
0x76, 0x9d, 0x5f, 0xed, 0x17, 0x26, 0xda, 0x85, 0x06, 0x65, 0x21, 0x89, 0xed, 0x86, 0xf0, 0x4b,
0x03, 0xed, 0x81, 0x45, 0x59, 0x98, 0xe4, 0xcc, 0xb6, 0x84, 0x5b, 0x59, 0xca, 0x8f, 0xb3, 0xcc,
0xbe, 0xb7, 0xf2, 0xe3, 0x2c, 0x43, 0x0e, 0x34, 0x19, 0xce, 0xe6, 0x24, 0x0e, 0x22, 0xbb, 0xd9,
0x37, 0x06, 0x4d, 0x7f, 0x65, 0xbb, 0x5f, 0xc2, 0x83, 0x62, 0x04, 0x34, 0x4d, 0x62, 0x8a, 0xb5,
0x33, 0x78, 0x08, 0xb5, 0x94, 0x84, 0x62, 0x04, 0x1d, 0x9f, 0x1f, 0xdd, 0xa7, 0xd0, 0x3e, 0x65,
0x41, 0xc6, 0x2a, 0xa6, 0xe7, 0x7e, 0x08, 0x9d, 0x63, 0x1c, 0xe1, 0xca, 0x31, 0xbb, 0x7f, 0x18,
0xf0, 0xa0, 0x88, 0xac, 0x40, 0xd3, 0x83, 0x16, 0xbe, 0x22, 0x6c, 0x42, 0x59, 0xc0, 0x72, 0xaa,
0x50, 0x01, 0x77, 0x9d, 0x0a, 0x0f, 0x3a, 0x80, 0xfb, 0xdc, 0xc2, 0xe1, 0x24, 0x60, 0x76, 0x4d,
0xbc, 0x9b, 0x73, 0xe3, 0xdd, 0x7e, 0x2c, 0x18, 0x71, 0xd8, 0xbc, 0x7e, 0xd5, 0xdb, 0xf9, 0xf3,
0xdf, 0x9e, 0xe1, 0x37, 0x65, 0xda, 0x01, 0x73, 0x9f, 0x40, 0xeb, 0x79, 0x7c, 0x9e, 0x54, 0xa1,
0xee, 0x40, 0xeb, 0x3b, 0x42, 0x8b, 0x29, 0xb8, 0xdf, 0x43, 0x5b, 0x9a, 0xaa, 0x83, 0x6f, 0x00,
0x56, 0x14, 0xa0, 0xb6, 0x21, 0x58, 0xd1, 0xbd, 0x95, 0x15, 0x47, 0x85, 0xcf, 0x2f, 0x65, 0xb8,
0x14, 0x5a, 0x27, 0x24, 0x8a, 0xaa, 0x28, 0xca, 0x1f, 0x9f, 0xcc, 0xf8, 0x13, 0xcb, 0x59, 0x28,
0x0b, 0x21, 0xa8, 0x05, 0x51, 0x24, 0x26, 0xd0, 0xfc, 0x76, 0xc7, 0xe7, 0x06, 0xf7, 0xf1, 0xa7,
0xe4, 0x64, 0xeb, 0x70, 0x5f, 0x4a, 0xc2, 0xc3, 0x36, 0x40, 0x4a, 0xc2, 0x49, 0x92, 0x4d, 0x82,
0x28, 0x72, 0xdf, 0x81, 0xce, 0xe8, 0x12, 0xc7, 0x8c, 0x16, 0x5d, 0xfd, 0x65, 0x40, 0x6b, 0x74,
0x85, 0xa7, 0x55, 0x30, 0xca, 0x5c, 0x33, 0x37, 0xb9, 0xb6, 0x66, 0x73, 0xed, 0x76, 0x36, 0xd7,
0x35, 0x6c, 0x6e, 0x6c, 0xb0, 0xb9, 0xd8, 0x45, 0xab, 0x6a, 0x17, 0xdd, 0x3e, 0xb4, 0x25, 0x64,
0xf5, 0x12, 0x8a, 0xc1, 0xc6, 0x9a, 0xc1, 0x21, 0xc0, 0x98, 0x2d, 0xaa, 0x7a, 0xba, 0xc1, 0x7c,
0xde, 0xc9, 0x2f, 0x24, 0x64, 0x17, 0xa2, 0x93, 0x8e, 0x2f, 0x0d, 0x8e, 0xf8, 0x02, 0x93, 0xd9,
0x85, 0xec, 0xa4, 0xe3, 0x2b, 0xcb, 0xfd, 0x1a, 0xde, 0x3d, 0x8a, 0x12, 0x8a, 0x4f, 0x79, 0xbf,
0x6f, 0x7d, 0x19, 0x5f, 0xb3, 0x71, 0x90, 0x53, 0xfc, 0x06, 0x6b, 0xe6, 0x63, 0x9a, 0xcf, 0x2b,
0x03, 0x1f, 0xc1, 0xfd, 0x31, 0xad, 0x0a, 0x7a, 0x09, 0xe6, 0x98, 0xde, 0x1c, 0x19, 0xfa, 0x1c,
0xda, 0x4a, 0x9d, 0x26, 0x61, 0xc0, 0x82, 0x3b, 0x25, 0xb1, 0xa5, 0x22, 0x8f, 0x03, 0x16, 0xb8,
0x5f, 0x00, 0xf0, 0x5b, 0xd5, 0x5b, 0x7c, 0x0c, 0x66, 0x5a, 0x6c, 0xc3, 0xb6, 0x46, 0x16, 0xdf,
0x24, 0x6f, 0x4c, 0x7d, 0x33, 0xa5, 0xfb, 0xbf, 0x37, 0xe1, 0xe1, 0x6a, 0x37, 0x4e, 0xe5, 0x9f,
0xe8, 0x27, 0xb0, 0xa4, 0x70, 0xa1, 0x27, 0xba, 0xf4, 0x0d, 0x6d, 0x77, 0x9e, 0x56, 0x85, 0x29,
0x64, 0x23, 0x68, 0x08, 0x55, 0x43, 0x8f, 0x75, 0x09, 0x65, 0xd1, 0x73, 0xf6, 0x6e, 0x74, 0x3e,
0xe2, 0x1f, 0x4e, 0x8e, 0x4f, 0x4a, 0x99, 0x1e, 0xdf, 0x86, 0x28, 0xea, 0xf1, 0x6d, 0x29, 0xe2,
0x09, 0xd4, 0xb9, 0x2a, 0xa1, 0x47, 0xba, 0xf8, 0x92, 0x66, 0x39, 0x15, 0x42, 0x83, 0x7e, 0x80,
0x3a, 0x17, 0x2b, 0x7d, 0xb1, 0x92, 0xb2, 0x39, 0x8f, 0xef, 0x0e, 0x52, 0xf8, 0x8e, 0xa0, 0xce,
0xf5, 0x4a, 0x5f, 0xb2, 0xa4, 0x66, 0xda, 0xe9, 0xbd, 0x00, 0x4b, 0xea, 0x8f, 0x7e, 0x7a, 0x1b,
0xfa, 0xe4, 0xdc, 0xfe, 0x9d, 0x15, 0x31, 0x9f, 0x18, 0xbc, 0x4d, 0xae, 0x04, 0x7a, 0x4c, 0x25,
0x69, 0xd3, 0xb7, 0xb9, 0x21, 0x26, 0x07, 0x50, 0x1b, 0xb3, 0x05, 0x72, 0xb5, 0xdc, 0x5d, 0xe9,
0x8a, 0xb6, 0xc9, 0x97, 0x00, 0x6b, 0x5d, 0x40, 0x1f, 0x69, 0xf9, 0xb9, 0xad, 0x1d, 0xda, 0x82,
0x23, 0x68, 0x08, 0xa5, 0xd0, 0x53, 0xb7, 0x2c, 0x24, 0xda, 0x32, 0xcf, 0xc0, 0x92, 0x42, 0xa2,
0x1f, 0xfe, 0x86, 0xd0, 0x68, 0x0b, 0x9d, 0x08, 0x0d, 0xf9, 0xe0, 0x8e, 0xf5, 0x56, 0x05, 0xdc,
0xbb, 0x42, 0xe4, 0xc0, 0x0f, 0xed, 0xeb, 0xd7, 0xdd, 0x9d, 0x7f, 0x5e, 0x77, 0x77, 0x7e, 0x5d,
0x76, 0x8d, 0xeb, 0x65, 0xd7, 0xf8, 0x7b, 0xd9, 0x35, 0xfe, 0x5b, 0x76, 0x8d, 0x33, 0x4b, 0x5c,
0xfb, 0xd9, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0x9b, 0x87, 0x9e, 0x96, 0x24, 0x0b, 0x00, 0x00,
// 930 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x55, 0xcf, 0x6f, 0xe3, 0x44,
0x14, 0xae, 0xf3, 0xc3, 0x9b, 0xbe, 0x34, 0x4b, 0x77, 0x54, 0x55, 0xc6, 0xa0, 0x24, 0x32, 0xbb,
0x4b, 0x96, 0x83, 0x03, 0xe5, 0xb6, 0x02, 0xa4, 0xfe, 0x88, 0x96, 0xd5, 0xb2, 0x6c, 0x71, 0x91,
0x38, 0x16, 0x37, 0x9e, 0x26, 0x23, 0x39, 0x1e, 0xe3, 0x19, 0x97, 0xe6, 0x06, 0x77, 0x0e, 0x1c,
0xf9, 0x37, 0xf8, 0x2f, 0x7a, 0xe4, 0xc8, 0x69, 0x61, 0xf3, 0x97, 0xa0, 0xf1, 0x8c, 0x13, 0x3b,
0xcd, 0xe0, 0xf6, 0x12, 0xcd, 0x7b, 0xf9, 0xde, 0xf8, 0x7b, 0x6f, 0xbe, 0xf9, 0x06, 0x5e, 0x4c,
0x08, 0x9f, 0xa6, 0x17, 0xee, 0x98, 0xce, 0x86, 0x63, 0x1a, 0x71, 0x9f, 0x44, 0x38, 0x09, 0x8a,
0x4b, 0x3f, 0x26, 0x43, 0x86, 0x93, 0x2b, 0x32, 0xc6, 0x6c, 0x88, 0xaf, 0xf1, 0x38, 0xe5, 0x84,
0x46, 0xab, 0x95, 0x1b, 0x27, 0x94, 0x53, 0xb4, 0xbf, 0x2a, 0x71, 0xaf, 0x3e, 0x73, 0xf3, 0x0a,
0xfb, 0x83, 0x09, 0xa5, 0x93, 0x10, 0x0f, 0x33, 0xd4, 0x45, 0x7a, 0x39, 0xc4, 0xb3, 0x98, 0xcf,
0x65, 0x91, 0xfd, 0xfe, 0xfa, 0x9f, 0x7e, 0x94, 0xff, 0xb5, 0x37, 0xa1, 0x13, 0x9a, 0x2d, 0x87,
0x62, 0xa5, 0xb2, 0x5f, 0xdc, 0x89, 0x2e, 0x9f, 0xc7, 0x98, 0x0d, 0x67, 0x34, 0x8d, 0xb8, 0xfc,
0x55, 0xd5, 0x27, 0xf7, 0xa8, 0x5e, 0x26, 0x57, 0x2b, 0xb5, 0x4b, 0x6f, 0x9d, 0x34, 0x27, 0x33,
0xcc, 0xb8, 0x3f, 0x8b, 0x25, 0xc0, 0xf9, 0xb5, 0x06, 0x9d, 0xe3, 0x04, 0xfb, 0x1c, 0x7b, 0xf8,
0xa7, 0x14, 0x33, 0x8e, 0xf6, 0xa1, 0x46, 0x02, 0xcb, 0xe8, 0x1b, 0x83, 0xed, 0x23, 0x73, 0xf1,
0xb6, 0x57, 0x7b, 0x79, 0xe2, 0xd5, 0x48, 0x80, 0x06, 0xd0, 0x60, 0x31, 0x1e, 0x5b, 0xb5, 0xbe,
0x31, 0x68, 0x1f, 0xec, 0xb9, 0x72, 0x67, 0x37, 0xdf, 0xd9, 0x3d, 0x8c, 0xe6, 0x5e, 0x86, 0x40,
0x07, 0x60, 0x26, 0x94, 0xf2, 0x4b, 0x66, 0xd5, 0xfb, 0xf5, 0x41, 0xfb, 0xc0, 0x76, 0xcb, 0xf3,
0xce, 0x48, 0xbb, 0xaf, 0x45, 0xb3, 0x9e, 0x42, 0x22, 0x0b, 0x1e, 0x24, 0x69, 0x24, 0xd8, 0x59,
0x0d, 0xf1, 0x69, 0x2f, 0x0f, 0xd1, 0x1e, 0x34, 0x19, 0x0f, 0x48, 0x64, 0x35, 0xb3, 0xbc, 0x0c,
0xd0, 0x3e, 0x98, 0x8c, 0x07, 0x34, 0xe5, 0x96, 0x99, 0xa5, 0x55, 0xa4, 0xf2, 0x38, 0x49, 0xac,
0x07, 0xcb, 0x3c, 0x4e, 0x12, 0x64, 0x43, 0x8b, 0xe3, 0x64, 0x46, 0x22, 0x3f, 0xb4, 0x5a, 0x7d,
0x63, 0xd0, 0xf2, 0x96, 0xb1, 0xf3, 0x1c, 0x1e, 0xe6, 0x23, 0x60, 0x31, 0x8d, 0x18, 0xd6, 0xce,
0x60, 0x17, 0xea, 0x31, 0x09, 0xb2, 0x11, 0x74, 0x3c, 0xb1, 0x74, 0x9e, 0xc2, 0xce, 0x19, 0xf7,
0x13, 0x5e, 0x31, 0x3d, 0xe7, 0x63, 0xe8, 0x9c, 0xe0, 0x10, 0x57, 0x8e, 0xd9, 0xf9, 0xcd, 0x80,
0x87, 0x39, 0xb2, 0x82, 0x4d, 0x0f, 0xda, 0xf8, 0x9a, 0xf0, 0x73, 0xc6, 0x7d, 0x9e, 0x32, 0xc5,
0x0a, 0x44, 0xea, 0x2c, 0xcb, 0xa0, 0x43, 0xd8, 0x16, 0x11, 0x0e, 0xce, 0x7d, 0x6e, 0xd5, 0xb3,
0x73, 0xb3, 0x6f, 0x9d, 0xdb, 0xf7, 0xb9, 0x22, 0x8e, 0x5a, 0x37, 0x6f, 0x7b, 0x5b, 0xbf, 0xff,
0xd3, 0x33, 0xbc, 0x96, 0x2c, 0x3b, 0xe4, 0xce, 0x13, 0x68, 0xbf, 0x8c, 0x2e, 0x69, 0x15, 0xeb,
0x0e, 0xb4, 0xbf, 0x21, 0x2c, 0x9f, 0x82, 0xf3, 0x2d, 0xec, 0xc8, 0x50, 0x75, 0xf0, 0x15, 0xc0,
0x52, 0x02, 0xcc, 0x32, 0x32, 0x55, 0x74, 0x37, 0xaa, 0xe2, 0x38, 0xcf, 0x79, 0x85, 0x0a, 0x87,
0x41, 0xfb, 0x15, 0x09, 0xc3, 0x2a, 0x89, 0x8a, 0xc3, 0x27, 0x13, 0x71, 0xc4, 0x72, 0x16, 0x2a,
0x42, 0x08, 0xea, 0x7e, 0x18, 0x66, 0x13, 0x68, 0x7d, 0xbd, 0xe5, 0x89, 0x40, 0xe4, 0xc4, 0x51,
0x0a, 0xb1, 0x75, 0x44, 0x2e, 0x26, 0xc1, 0xd1, 0x0e, 0x40, 0x4c, 0x82, 0x73, 0x9a, 0x9c, 0xfb,
0x61, 0xe8, 0xbc, 0x07, 0x9d, 0xd1, 0x15, 0x8e, 0x38, 0xcb, 0xbb, 0xfa, 0xd3, 0x80, 0xf6, 0xe8,
0x1a, 0x8f, 0xab, 0x68, 0x14, 0xb5, 0x56, 0x2b, 0x6b, 0x6d, 0xa5, 0xe6, 0xfa, 0x66, 0x35, 0x37,
0x34, 0x6a, 0x6e, 0x96, 0xd4, 0x9c, 0xdf, 0x45, 0xb3, 0xea, 0x2e, 0x3a, 0x7d, 0xd8, 0x91, 0x94,
0xd5, 0x49, 0x28, 0x05, 0x1b, 0x2b, 0x05, 0x07, 0x00, 0xa7, 0x7c, 0x5e, 0xd5, 0xd3, 0x2d, 0xe5,
0x8b, 0x4e, 0x7e, 0x26, 0x01, 0x9f, 0x66, 0x9d, 0x74, 0x3c, 0x19, 0x08, 0xc6, 0x53, 0x4c, 0x26,
0x53, 0xd9, 0x49, 0xc7, 0x53, 0x91, 0xf3, 0x25, 0x3c, 0x3a, 0x0e, 0x29, 0xc3, 0x67, 0xa2, 0xdf,
0x7b, 0x7f, 0x4c, 0x5c, 0xb3, 0x53, 0x3f, 0x65, 0xf8, 0x0e, 0xd7, 0xcc, 0xc3, 0x2c, 0x9d, 0x55,
0x02, 0x3f, 0x81, 0xdd, 0xd3, 0x84, 0x8e, 0x31, 0x63, 0x98, 0x55, 0x61, 0xdf, 0xc0, 0xa3, 0x02,
0x56, 0x0d, 0xf2, 0x39, 0x6c, 0xc7, 0x79, 0x52, 0x29, 0xfa, 0xc3, 0x8d, 0x8a, 0x56, 0xa5, 0xde,
0x0a, 0x7e, 0xf0, 0x47, 0x0b, 0x76, 0x97, 0x42, 0x3f, 0x93, 0xaf, 0x0f, 0xfa, 0x01, 0x4c, 0xe9,
0x42, 0xe8, 0x89, 0xbb, 0xf9, 0x7d, 0x72, 0x4b, 0x46, 0x6d, 0x3f, 0xad, 0x82, 0x29, 0xa6, 0x23,
0x68, 0x66, 0x16, 0x85, 0x1e, 0xeb, 0x0a, 0x8a, 0x0e, 0x66, 0xef, 0xdf, 0x52, 0xd3, 0x48, 0xbc,
0x82, 0x82, 0x9f, 0xf4, 0x25, 0x3d, 0xbf, 0x92, 0xc3, 0xe9, 0xf9, 0xad, 0xd9, 0xdb, 0x2b, 0x68,
0x08, 0x8b, 0x41, 0x1f, 0xe9, 0xf0, 0x05, 0x03, 0xb2, 0x2b, 0x5c, 0x03, 0x7d, 0x07, 0x0d, 0xe1,
0x3c, 0xfa, 0xcd, 0x0a, 0x36, 0x65, 0x3f, 0xfe, 0x7f, 0x90, 0xe2, 0x77, 0x0c, 0x0d, 0x61, 0x3e,
0xfa, 0x2d, 0x0b, 0xd6, 0xa4, 0x9d, 0xde, 0x6b, 0x30, 0xa5, 0x99, 0xe8, 0xa7, 0x57, 0x32, 0x1b,
0x7b, 0xf3, 0xa3, 0x99, 0x61, 0x3e, 0x35, 0x44, 0x9b, 0xe2, 0x5a, 0xeb, 0x39, 0x15, 0x7c, 0x4a,
0xdf, 0x66, 0xc9, 0x19, 0x0e, 0xa1, 0x7e, 0xca, 0xe7, 0xc8, 0xd1, 0x81, 0x57, 0x26, 0xa1, 0x6d,
0xf2, 0x0d, 0xc0, 0xea, 0x92, 0xa3, 0x67, 0x5a, 0x7d, 0xae, 0x1b, 0x81, 0x76, 0xc3, 0x11, 0x34,
0xb3, 0x6b, 0xaf, 0x97, 0x6e, 0xd1, 0x15, 0xb4, 0xdb, 0xbc, 0x00, 0x53, 0xba, 0x82, 0x7e, 0xf8,
0x25, 0xd7, 0xd0, 0x6e, 0xf4, 0x23, 0x6c, 0x2f, 0x9d, 0x00, 0x0d, 0xb4, 0x9c, 0xd6, 0x8c, 0xc5,
0x7e, 0x76, 0x07, 0xa4, 0x3c, 0x85, 0x23, 0xeb, 0xe6, 0x5d, 0x77, 0xeb, 0xef, 0x77, 0xdd, 0xad,
0x5f, 0x16, 0x5d, 0xe3, 0x66, 0xd1, 0x35, 0xfe, 0x5a, 0x74, 0x8d, 0x7f, 0x17, 0x5d, 0xe3, 0xc2,
0xcc, 0xb8, 0x7c, 0xfe, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x76, 0x89, 0x1c, 0x40, 0x06, 0x0b,
0x00, 0x00,
}

13
api/services/execution/execution.proto
View File

@ -22,7 +22,7 @@ service ContainerService {
rpc CloseStdin(CloseStdinRequest) returns (google.protobuf.Empty);
rpc Pause(PauseRequest) returns (google.protobuf.Empty);
rpc Resume(ResumeRequest) returns (google.protobuf.Empty);
rpc Ps(PsRequest) returns (PsResponse);
rpc Processes(ProcessesRequest) returns (ProcessesResponse);
}
message CreateRequest {
@ -111,15 +111,10 @@ message ResumeRequest {
string id = 1 [(gogoproto.customname) = "ID"];
}
message PsRequest {
message ProcessesRequest {
string id = 1 [(gogoproto.customname) = "ID"];
}
message Ps {
uint32 pid = 1;
google.protobuf.Any runtime_data = 2;
}
message PsResponse{
repeated Ps ps = 1;
message ProcessesResponse{
repeated containerd.v1.types.Process processes = 1;
}

149
api/types/container/container.pb.go
View File

@ -19,6 +19,7 @@ package container
import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import google_protobuf "github.com/gogo/protobuf/types"
import _ "github.com/gogo/protobuf/gogoproto"
import _ "github.com/gogo/protobuf/types"
@ -125,6 +126,7 @@ type Process struct {
Terminal bool `protobuf:"varint,6,opt,name=terminal,proto3" json:"terminal,omitempty"`
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_protobuf.Any `protobuf:"bytes,9,opt,name=runtime_data,json=runtimeData" json:"runtime_data,omitempty"`
}
func (m *Process) Reset() { *m = Process{} }
@ -281,6 +283,16 @@ func (m *Process) MarshalTo(dAtA []byte) (int, error) {
i++
i = encodeVarintContainer(dAtA, i, uint64(m.Status))
}
if m.RuntimeData != nil {
dAtA[i] = 0x4a
i++
i = encodeVarintContainer(dAtA, i, uint64(m.RuntimeData.Size()))
n2, err := m.RuntimeData.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n2
}
return i, nil
}
@ -310,21 +322,21 @@ func (m *User) MarshalTo(dAtA []byte) (int, error) {
i = encodeVarintContainer(dAtA, i, uint64(m.Gid))
}
if len(m.AdditionalGids) > 0 {
dAtA3 := make([]byte, len(m.AdditionalGids)*10)
var j2 int
dAtA4 := make([]byte, len(m.AdditionalGids)*10)
var j3 int
for _, num := range m.AdditionalGids {
for num >= 1<<7 {
dAtA3[j2] = uint8(uint64(num)&0x7f | 0x80)
dAtA4[j3] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j2++
j3++
}
dAtA3[j2] = uint8(num)
j2++
dAtA4[j3] = uint8(num)
j3++
}
dAtA[i] = 0x1a
i++
i = encodeVarintContainer(dAtA, i, uint64(j2))
i += copy(dAtA[i:], dAtA3[:j2])
i = encodeVarintContainer(dAtA, i, uint64(j3))
i += copy(dAtA[i:], dAtA4[:j3])
}
return i, nil
}
@ -368,11 +380,11 @@ func (m *Event) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x2a
i++
i = encodeVarintContainer(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.ExitedAt)))
n4, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ExitedAt, dAtA[i:])
n5, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ExitedAt, dAtA[i:])
if err != nil {
return 0, err
}
i += n4
i += n5
return i, nil
}
@ -454,6 +466,10 @@ func (m *Process) Size() (n int) {
if m.Status != 0 {
n += 1 + sovContainer(uint64(m.Status))
}
if m.RuntimeData != nil {
l = m.RuntimeData.Size()
n += 1 + l + sovContainer(uint64(l))
}
return n
}
@ -535,6 +551,7 @@ func (this *Process) String() string {
`Terminal:` + fmt.Sprintf("%v", this.Terminal) + `,`,
`ExitStatus:` + fmt.Sprintf("%v", this.ExitStatus) + `,`,
`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
`RuntimeData:` + strings.Replace(fmt.Sprintf("%v", this.RuntimeData), "Any", "google_protobuf.Any", 1) + `,`,
`}`,
}, "")
return s
@ -560,7 +577,7 @@ func (this *Event) String() string {
`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
`Pid:` + fmt.Sprintf("%v", this.Pid) + `,`,
`ExitStatus:` + fmt.Sprintf("%v", this.ExitStatus) + `,`,
`ExitedAt:` + strings.Replace(strings.Replace(this.ExitedAt.String(), "Timestamp", "google_protobuf1.Timestamp", 1), `&`, ``, 1) + `,`,
`ExitedAt:` + strings.Replace(strings.Replace(this.ExitedAt.String(), "Timestamp", "google_protobuf2.Timestamp", 1), `&`, ``, 1) + `,`,
`}`,
}, "")
return s
@ -916,6 +933,39 @@ func (m *Process) Unmarshal(dAtA []byte) error {
break
}
}
case 9:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field RuntimeData", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowContainer
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthContainer
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.RuntimeData == nil {
m.RuntimeData = &google_protobuf.Any{}
}
if err := m.RuntimeData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipContainer(dAtA[iNdEx:])
@ -1363,41 +1413,44 @@ func init() {
}
var fileDescriptorContainer = []byte{
// 576 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x52, 0xcf, 0x6e, 0xd3, 0x4e,
0x18, 0xcc, 0xda, 0xce, 0xbf, 0x2f, 0x6a, 0x7e, 0xd6, 0xfe, 0x10, 0x32, 0x41, 0x4a, 0xa2, 0x08,
0x09, 0x0b, 0x09, 0x47, 0xa4, 0x17, 0xae, 0x6e, 0x6d, 0x95, 0x0a, 0xe1, 0x84, 0x8d, 0x23, 0x7a,
0x8b, 0xdc, 0x78, 0x31, 0x8b, 0x1a, 0xdb, 0xb2, 0xd7, 0x85, 0xde, 0x78, 0x04, 0x9e, 0x81, 0xa7,
0xe9, 0x91, 0x23, 0xa7, 0x42, 0xf3, 0x0c, 0x3c, 0x00, 0xda, 0x75, 0x52, 0x57, 0x50, 0x24, 0x2e,
0xd1, 0xcc, 0x97, 0xd9, 0xf1, 0xcc, 0xb7, 0x0b, 0x4e, 0xc4, 0xf8, 0xbb, 0xe2, 0xd4, 0x5a, 0x25,
0xeb, 0xf1, 0x2a, 0x89, 0x79, 0xc0, 0x62, 0x9a, 0x85, 0xb7, 0x61, 0x90, 0xb2, 0x31, 0xbf, 0x48,
0x69, 0x5e, 0x0d, 0x2b, 0x64, 0xa5, 0x59, 0xc2, 0x13, 0xfc, 0x7f, 0xa5, 0xb7, 0xce, 0x9f, 0x59,
0x52, 0xde, 0xbb, 0x17, 0x25, 0x51, 0x22, 0xff, 0x1f, 0x0b, 0x54, 0x4a, 0x7b, 0x83, 0x28, 0x49,
0xa2, 0x33, 0x3a, 0x96, 0xec, 0xb4, 0x78, 0x3b, 0xe6, 0x6c, 0x4d, 0x73, 0x1e, 0xac, 0xd3, 0x52,
0x30, 0x7a, 0x0f, 0xed, 0xc3, 0x9d, 0x1b, 0xbe, 0x0f, 0x0a, 0x0b, 0x0d, 0x34, 0x44, 0x66, 0xfb,
0xa0, 0xb1, 0xb9, 0x1a, 0x28, 0xc7, 0x0e, 0x51, 0x58, 0x88, 0x75, 0x50, 0x53, 0x16, 0x1a, 0xca,
0x10, 0x99, 0x7b, 0x44, 0x40, 0xbc, 0x0f, 0x8d, 0x9c, 0x07, 0xbc, 0xc8, 0x0d, 0x75, 0x88, 0xcc,
0xee, 0xe4, 0xa1, 0x75, 0x47, 0x26, 0x6b, 0x2e, 0x25, 0x64, 0x2b, 0x1d, 0xfd, 0x44, 0xd0, 0x9c,
0x65, 0xc9, 0x8a, 0xe6, 0xf9, 0xce, 0x12, 0x55, 0x96, 0x18, 0xb4, 0x20, 0x8b, 0x72, 0x43, 0x19,
0xaa, 0x66, 0x9b, 0x48, 0x2c, 0x54, 0x34, 0x3e, 0x37, 0x54, 0x39, 0x12, 0x10, 0x3f, 0x05, 0xad,
0xc8, 0x69, 0x66, 0x68, 0x43, 0x64, 0x76, 0x26, 0x0f, 0xee, 0xfc, 0xec, 0x22, 0xa7, 0x19, 0x91,
0x32, 0x61, 0xb0, 0xfa, 0x10, 0x1a, 0x75, 0x51, 0x89, 0x08, 0x88, 0x7b, 0xd0, 0xe2, 0x34, 0x5b,
0xb3, 0x38, 0x38, 0x33, 0x1a, 0x43, 0x64, 0xb6, 0xc8, 0x0d, 0xc7, 0x03, 0xe8, 0xd0, 0x8f, 0x8c,
0x2f, 0xb7, 0xd5, 0x9a, 0x32, 0x1c, 0x88, 0x51, 0xd9, 0xe4, 0x56, 0xed, 0xd6, 0xbf, 0xd7, 0x9e,
0x83, 0xb6, 0xd8, 0x66, 0x29, 0xaa, 0xca, 0x45, 0xb9, 0xd7, 0xa8, 0xda, 0x6b, 0xc4, 0x42, 0xfc,
0x18, 0xfe, 0x0b, 0xc2, 0x90, 0x71, 0x96, 0xc4, 0xc1, 0xd9, 0x32, 0x62, 0x61, 0x2e, 0xcb, 0xef,
0x91, 0x6e, 0x35, 0x3e, 0x62, 0x61, 0x3e, 0xfa, 0xa2, 0x40, 0xdd, 0x3d, 0xa7, 0x31, 0xff, 0xeb,
0xa5, 0x3d, 0x07, 0x4d, 0xc4, 0x91, 0xee, 0xdd, 0xc9, 0xa3, 0x3b, 0x93, 0x4a, 0x87, 0xf2, 0xd7,
0xbf, 0x48, 0x29, 0x91, 0x27, 0x76, 0x77, 0xa3, 0x56, 0x77, 0xf3, 0xdb, 0x62, 0xb4, 0x3f, 0x16,
0x63, 0x43, 0x5b, 0x30, 0x1a, 0x2e, 0x03, 0x2e, 0xb7, 0xdd, 0x99, 0xf4, 0xac, 0xf2, 0xed, 0x59,
0xbb, 0xb7, 0x67, 0xf9, 0xbb, 0xb7, 0x77, 0xd0, 0xba, 0xbc, 0x1a, 0xd4, 0x3e, 0x7f, 0x1f, 0x20,
0xd2, 0x2a, 0x8f, 0xd9, 0x7c, 0xf4, 0x1a, 0xda, 0x37, 0x41, 0x70, 0x0b, 0x34, 0xf7, 0xe4, 0xd8,
0xd7, 0x6b, 0xb8, 0x09, 0xea, 0x74, 0xfa, 0x4a, 0x47, 0x18, 0xa0, 0x71, 0x48, 0x5c, 0xdb, 0x77,
0x75, 0x05, 0xb7, 0xa1, 0x3e, 0xf7, 0x6d, 0xe2, 0xeb, 0x2a, 0xee, 0x02, 0xb8, 0x27, 0xee, 0xe1,
0xd2, 0x76, 0x1c, 0xd7, 0xd1, 0x35, 0x21, 0x9b, 0xd9, 0x8b, 0xb9, 0xeb, 0xe8, 0xf5, 0x27, 0x2f,
0xa0, 0xb1, 0xcd, 0xd7, 0x81, 0xe6, 0xc2, 0x7b, 0xe9, 0x4d, 0xdf, 0x78, 0x7a, 0x4d, 0x90, 0xd2,
0xc9, 0xd1, 0x91, 0x20, 0x64, 0xe1, 0x79, 0xc7, 0xde, 0x91, 0xae, 0x08, 0x32, 0xf7, 0xa7, 0xb3,
0x99, 0xeb, 0xe8, 0xea, 0x2d, 0x27, 0xed, 0xc0, 0xb8, 0xbc, 0xee, 0xd7, 0xbe, 0x5d, 0xf7, 0x6b,
0x9f, 0x36, 0x7d, 0x74, 0xb9, 0xe9, 0xa3, 0xaf, 0x9b, 0x3e, 0xfa, 0xb1, 0xe9, 0xa3, 0xd3, 0x86,
0xac, 0xb7, 0xff, 0x2b, 0x00, 0x00, 0xff, 0xff, 0xa6, 0xfb, 0xbb, 0xac, 0xdb, 0x03, 0x00, 0x00,
// 612 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x52, 0xcd, 0x6e, 0xd3, 0x4c,
0x14, 0xcd, 0xd8, 0xce, 0x8f, 0x6f, 0xbe, 0xe6, 0xb3, 0x86, 0x0a, 0xb9, 0x41, 0x4a, 0xa2, 0x08,
0x89, 0x08, 0x09, 0x47, 0xa4, 0x0b, 0xd8, 0xba, 0xb5, 0x55, 0x2a, 0x44, 0x12, 0x26, 0x8e, 0xe8,
0x2e, 0x9a, 0xc6, 0xc6, 0x0c, 0x6a, 0xec, 0xc8, 0x1e, 0x17, 0xb2, 0xe3, 0x11, 0x78, 0x06, 0xf6,
0xbc, 0x47, 0x97, 0x2c, 0x59, 0x15, 0x9a, 0x27, 0x41, 0x33, 0x4e, 0xea, 0xaa, 0x2d, 0x12, 0x1b,
0xeb, 0xdc, 0xab, 0x73, 0xcf, 0xdc, 0x73, 0x8f, 0xc1, 0x09, 0x19, 0xff, 0x90, 0x9d, 0x5a, 0xf3,
0x78, 0xd1, 0x9f, 0xc7, 0x11, 0xa7, 0x2c, 0x0a, 0x12, 0xff, 0x26, 0xa4, 0x4b, 0xd6, 0xe7, 0xab,
0x65, 0x90, 0x16, 0xcd, 0x02, 0x59, 0xcb, 0x24, 0xe6, 0x31, 0x7e, 0x50, 0xf0, 0xad, 0xf3, 0xe7,
0x96, 0xa4, 0x37, 0xf7, 0xc2, 0x38, 0x0e, 0xcf, 0x82, 0xbe, 0xa4, 0x9c, 0x66, 0xef, 0xfb, 0x34,
0x5a, 0xe5, 0xfc, 0xe6, 0x6e, 0x18, 0x87, 0xb1, 0x84, 0x7d, 0x81, 0x36, 0xdd, 0xf6, 0xed, 0x01,
0xce, 0x16, 0x41, 0xca, 0xe9, 0x62, 0x99, 0x13, 0xba, 0x1f, 0x41, 0x3f, 0xdc, 0x3e, 0x84, 0x1f,
0x82, 0xc2, 0x7c, 0x13, 0x75, 0x50, 0x4f, 0x3f, 0xa8, 0xac, 0x2f, 0xdb, 0xca, 0xb1, 0x43, 0x14,
0xe6, 0x63, 0x03, 0xd4, 0x25, 0xf3, 0x4d, 0xa5, 0x83, 0x7a, 0x3b, 0x44, 0x40, 0xbc, 0x0f, 0x95,
0x94, 0x53, 0x9e, 0xa5, 0xa6, 0xda, 0x41, 0xbd, 0xc6, 0xe0, 0x91, 0x75, 0xcf, 0xba, 0xd6, 0x44,
0x52, 0xc8, 0x86, 0xda, 0xfd, 0xae, 0x40, 0x75, 0x9c, 0xc4, 0xf3, 0x20, 0x4d, 0xb7, 0x92, 0xa8,
0x90, 0xc4, 0xa0, 0xd1, 0x24, 0x4c, 0x4d, 0xa5, 0xa3, 0xf6, 0x74, 0x22, 0xb1, 0x60, 0x05, 0xd1,
0xb9, 0xa9, 0xca, 0x96, 0x80, 0xf8, 0x19, 0x68, 0x59, 0x1a, 0x24, 0xa6, 0xd6, 0x41, 0xbd, 0xfa,
0x60, 0xef, 0xde, 0x67, 0xa7, 0x69, 0x90, 0x10, 0x49, 0x13, 0x02, 0xf3, 0x4f, 0xbe, 0x59, 0x16,
0x96, 0x88, 0x80, 0xb8, 0x09, 0x35, 0x1e, 0x24, 0x0b, 0x16, 0xd1, 0x33, 0xb3, 0xd2, 0x41, 0xbd,
0x1a, 0xb9, 0xae, 0x71, 0x1b, 0xea, 0xc1, 0x67, 0xc6, 0x67, 0x1b, 0x6b, 0x55, 0xb9, 0x1c, 0x88,
0x56, 0xee, 0xe4, 0x86, 0xed, 0xda, 0x3f, 0xdb, 0xc6, 0x2f, 0xe0, 0xbf, 0x24, 0x8b, 0xc4, 0xe1,
0x67, 0x3e, 0xe5, 0xd4, 0xd4, 0xe5, 0xea, 0xbb, 0x56, 0x1e, 0x8d, 0xb5, 0x8d, 0xc6, 0xb2, 0xa3,
0x15, 0xa9, 0x6f, 0x98, 0x0e, 0xe5, 0xb4, 0x3b, 0x01, 0x6d, 0xba, 0x31, 0x91, 0x15, 0xb7, 0xca,
0xf2, 0x40, 0xc2, 0x22, 0x90, 0x90, 0xf9, 0xf8, 0x09, 0xfc, 0x4f, 0x7d, 0x9f, 0x71, 0x16, 0x47,
0xf4, 0x6c, 0x16, 0x32, 0x3f, 0x95, 0x57, 0xdb, 0x21, 0x8d, 0xa2, 0x7d, 0xc4, 0xfc, 0xb4, 0xfb,
0x4d, 0x81, 0xb2, 0x7b, 0x1e, 0x44, 0xfc, 0xaf, 0x69, 0xbf, 0x04, 0x4d, 0xf8, 0x90, 0xea, 0x8d,
0xc1, 0xe3, 0x7b, 0x2d, 0x4a, 0x85, 0xfc, 0xeb, 0xad, 0x96, 0x01, 0x91, 0x13, 0xdb, 0x50, 0xd5,
0x22, 0xd4, 0x5b, 0x17, 0xd5, 0xee, 0x5c, 0xd4, 0x06, 0x5d, 0x54, 0x81, 0x3f, 0xa3, 0x5c, 0xc6,
0x54, 0x1f, 0x34, 0xef, 0x5c, 0xc6, 0xdb, 0xfe, 0xb4, 0x07, 0xb5, 0x8b, 0xcb, 0x76, 0xe9, 0xeb,
0xaf, 0x36, 0x22, 0xb5, 0x7c, 0xcc, 0xe6, 0xdd, 0xb7, 0xa0, 0x5f, 0x2f, 0x82, 0x6b, 0xa0, 0xb9,
0x27, 0xc7, 0x9e, 0x51, 0xc2, 0x55, 0x50, 0x47, 0xa3, 0x37, 0x06, 0xc2, 0x00, 0x95, 0x43, 0xe2,
0xda, 0x9e, 0x6b, 0x28, 0x58, 0x87, 0xf2, 0xc4, 0xb3, 0x89, 0x67, 0xa8, 0xb8, 0x01, 0xe0, 0x9e,
0xb8, 0x87, 0x33, 0xdb, 0x71, 0x5c, 0xc7, 0xd0, 0x04, 0x6d, 0x6c, 0x4f, 0x27, 0xae, 0x63, 0x94,
0x9f, 0xbe, 0x82, 0xca, 0x66, 0xbf, 0x3a, 0x54, 0xa7, 0xc3, 0xd7, 0xc3, 0xd1, 0xbb, 0xa1, 0x51,
0x12, 0x45, 0xae, 0xe4, 0x18, 0x48, 0x14, 0x64, 0x3a, 0x1c, 0x1e, 0x0f, 0x8f, 0x0c, 0x45, 0x14,
0x13, 0x6f, 0x34, 0x1e, 0xbb, 0x8e, 0xa1, 0xde, 0x50, 0xd2, 0x0e, 0xcc, 0x8b, 0xab, 0x56, 0xe9,
0xe7, 0x55, 0xab, 0xf4, 0x65, 0xdd, 0x42, 0x17, 0xeb, 0x16, 0xfa, 0xb1, 0x6e, 0xa1, 0xdf, 0xeb,
0x16, 0x3a, 0xad, 0x48, 0x7b, 0xfb, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x2c, 0x9b, 0x55, 0x0d,
0x2f, 0x04, 0x00, 0x00,
}

2
api/types/container/container.proto
View File

@ -2,6 +2,7 @@ syntax = "proto3";
package containerd.v1.types;
import "google/protobuf/any.proto";
import "gogoproto/gogo.proto";
import "google/protobuf/timestamp.proto";
@ -28,6 +29,7 @@ message Process {
bool terminal = 6;
uint32 exit_status = 7;
Status status = 8;
google.protobuf.Any runtime_data = 9;
}
message User {

6
cmd/ctr/ps.go
View File

@ -26,7 +26,7 @@ var psCommand = cli.Command{
return errors.New("container id must be provided")
}
psRequest := &execution.PsRequest{
pr := &execution.ProcessesRequest{
ID: id,
}
@ -35,14 +35,14 @@ var psCommand = cli.Command{
return err
}
resp, err := containers.Ps(gocontext.Background(), psRequest)
resp, err := containers.Processes(gocontext.Background(), pr)
if err != nil {
return err
}
w := tabwriter.NewWriter(os.Stdout, 10, 1, 3, ' ', 0)
fmt.Fprintln(w, "PID")
for _, ps := range resp.Ps {
for _, ps := range resp.Processes {
if _, err := fmt.Fprintf(w, "%d\n",
ps.Pid,
); err != nil {

10
services/execution/service.go
View File

@ -234,7 +234,7 @@ func (s *Service) Kill(ctx context.Context, r *api.KillRequest) (*google_protobu
return empty, nil
}
func (s *Service) Ps(ctx context.Context, r *api.PsRequest) (*api.PsResponse, error) {
func (s *Service) Processes(ctx context.Context, r *api.ProcessesRequest) (*api.ProcessesResponse, error) {
c, err := s.getContainer(r.ID)
if err != nil {
return nil, err
@ -245,15 +245,15 @@ func (s *Service) Ps(ctx context.Context, r *api.PsRequest) (*api.PsResponse, er
return nil, err
}
ps := []*api.Ps{}
ps := []*container.Process{}
for _, pid := range pids {
ps = append(ps, &api.Ps{
ps = append(ps, &container.Process{
Pid: pid,
})
}
resp := &api.PsResponse{
Ps: ps,
resp := &api.ProcessesResponse{
Processes: ps,
}
return resp, nil