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

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

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

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

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