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

shim: Ps -> Processes

Browse Source 
Signed-off-by: Evan Hazlett <ejhazlett@gmail.com>
This commit is contained in:
Evan Hazlett 2017-05-17 12:58:03 -04:00
parent 395d21018f
commit 70dd7fcc60
9 changed files with 132 additions and 309 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -26,9 +26,8 @@
ExitRequest ExitRequest
KillRequest KillRequest
CloseStdinRequest CloseStdinRequest
PsRequest ProcessesRequest
Ps ProcessesResponse
PsResponse
*/ */
package shim package shim
@ -221,30 +220,21 @@ func (m *CloseStdinRequest) Reset() { *m = CloseStdinRequest{
func (*CloseStdinRequest) ProtoMessage() {} func (*CloseStdinRequest) ProtoMessage() {}
func (*CloseStdinRequest) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{16} } func (*CloseStdinRequest) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{16} }
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 fileDescriptorShim, []int{17} } func (*ProcessesRequest) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{17} }
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_protobuf.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 fileDescriptorShim, []int{18} } func (*ProcessesResponse) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{18} }
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 fileDescriptorShim, []int{19} }
func init() { func init() {
proto.RegisterType((*CreateRequest)(nil), "containerd.v1.services.shim.CreateRequest") proto.RegisterType((*CreateRequest)(nil), "containerd.v1.services.shim.CreateRequest")
@ -264,9 +254,8 @@ func init() {
proto.RegisterType((*ExitRequest)(nil), "containerd.v1.services.shim.ExitRequest") proto.RegisterType((*ExitRequest)(nil), "containerd.v1.services.shim.ExitRequest")
proto.RegisterType((*KillRequest)(nil), "containerd.v1.services.shim.KillRequest") proto.RegisterType((*KillRequest)(nil), "containerd.v1.services.shim.KillRequest")
proto.RegisterType((*CloseStdinRequest)(nil), "containerd.v1.services.shim.CloseStdinRequest") proto.RegisterType((*CloseStdinRequest)(nil), "containerd.v1.services.shim.CloseStdinRequest")
proto.RegisterType((*PsRequest)(nil), "containerd.v1.services.shim.PsRequest") proto.RegisterType((*ProcessesRequest)(nil), "containerd.v1.services.shim.ProcessesRequest")
proto.RegisterType((*Ps)(nil), "containerd.v1.services.shim.Ps") proto.RegisterType((*ProcessesResponse)(nil), "containerd.v1.services.shim.ProcessesResponse")
proto.RegisterType((*PsResponse)(nil), "containerd.v1.services.shim.PsResponse")
} }
// Reference imports to suppress errors if they are not otherwise used. // Reference imports to suppress errors if they are not otherwise used.
@ -284,7 +273,7 @@ type ShimClient interface {
Start(ctx context.Context, in *StartRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) Start(ctx context.Context, in *StartRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error)
Delete(ctx context.Context, in *DeleteRequest, opts ...grpc.CallOption) (*DeleteResponse, error) Delete(ctx context.Context, in *DeleteRequest, opts ...grpc.CallOption) (*DeleteResponse, error)
State(ctx context.Context, in *StateRequest, opts ...grpc.CallOption) (*StateResponse, error) State(ctx context.Context, in *StateRequest, opts ...grpc.CallOption) (*StateResponse, error)
Ps(ctx context.Context, in *PsRequest, opts ...grpc.CallOption) (*PsResponse, error) Processes(ctx context.Context, in *ProcessesRequest, opts ...grpc.CallOption) (*ProcessesResponse, error)
Pause(ctx context.Context, in *PauseRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) Pause(ctx context.Context, in *PauseRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error)
Resume(ctx context.Context, in *ResumeRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) Resume(ctx context.Context, in *ResumeRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error)
Exit(ctx context.Context, in *ExitRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) Exit(ctx context.Context, in *ExitRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error)
@ -339,9 +328,9 @@ func (c *shimClient) State(ctx context.Context, in *StateRequest, opts ...grpc.C
return out, nil return out, nil
} }
func (c *shimClient) Ps(ctx context.Context, in *PsRequest, opts ...grpc.CallOption) (*PsResponse, error) { func (c *shimClient) Processes(ctx context.Context, in *ProcessesRequest, opts ...grpc.CallOption) (*ProcessesResponse, error) {
out := new(PsResponse) out := new(ProcessesResponse)
err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/Ps", in, out, c.cc, opts...) err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/Processes", in, out, c.cc, opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -450,7 +439,7 @@ type ShimServer interface {
Start(context.Context, *StartRequest) (*google_protobuf1.Empty, error) Start(context.Context, *StartRequest) (*google_protobuf1.Empty, error)
Delete(context.Context, *DeleteRequest) (*DeleteResponse, error) Delete(context.Context, *DeleteRequest) (*DeleteResponse, error)
State(context.Context, *StateRequest) (*StateResponse, error) State(context.Context, *StateRequest) (*StateResponse, error)
Ps(context.Context, *PsRequest) (*PsResponse, error) Processes(context.Context, *ProcessesRequest) (*ProcessesResponse, error)
Pause(context.Context, *PauseRequest) (*google_protobuf1.Empty, error) Pause(context.Context, *PauseRequest) (*google_protobuf1.Empty, error)
Resume(context.Context, *ResumeRequest) (*google_protobuf1.Empty, error) Resume(context.Context, *ResumeRequest) (*google_protobuf1.Empty, error)
Exit(context.Context, *ExitRequest) (*google_protobuf1.Empty, error) Exit(context.Context, *ExitRequest) (*google_protobuf1.Empty, error)
@ -537,20 +526,20 @@ func _Shim_State_Handler(srv interface{}, ctx context.Context, dec func(interfac
return interceptor(ctx, in, info, handler) return interceptor(ctx, in, info, handler)
} }
func _Shim_Ps_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { func _Shim_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.(ShimServer).Ps(ctx, in) return srv.(ShimServer).Processes(ctx, in)
} }
info := &grpc.UnaryServerInfo{ info := &grpc.UnaryServerInfo{
Server: srv, Server: srv,
FullMethod: "/containerd.v1.services.shim.Shim/Ps", FullMethod: "/containerd.v1.services.shim.Shim/Processes",
} }
handler := func(ctx context.Context, req interface{}) (interface{}, error) { handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ShimServer).Ps(ctx, req.(*PsRequest)) return srv.(ShimServer).Processes(ctx, req.(*ProcessesRequest))
} }
return interceptor(ctx, in, info, handler) return interceptor(ctx, in, info, handler)
} }
@ -723,8 +712,8 @@ var _Shim_serviceDesc = grpc.ServiceDesc{
Handler: _Shim_State_Handler, Handler: _Shim_State_Handler,
}, },
{ {
MethodName: "Ps", MethodName: "Processes",
Handler: _Shim_Ps_Handler, Handler: _Shim_Processes_Handler,
}, },
{ {
MethodName: "Pause", MethodName: "Pause",
@ -1295,7 +1284,7 @@ func (m *CloseStdinRequest) 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)
@ -1305,7 +1294,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
@ -1319,7 +1308,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)
@ -1329,46 +1318,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 = encodeVarintShim(dAtA, i, uint64(m.Pid))
}
if m.RuntimeData != nil {
dAtA[i] = 0x12
i++
i = encodeVarintShim(dAtA, i, uint64(m.RuntimeData.Size()))
n3, err := m.RuntimeData.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n3
}
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 = encodeVarintShim(dAtA, i, uint64(msg.Size())) i = encodeVarintShim(dAtA, i, uint64(msg.Size()))
@ -1631,7 +1587,7 @@ func (m *CloseStdinRequest) 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)
@ -1641,24 +1597,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 + sovShim(uint64(m.Pid)) for _, e := range m.Processes {
}
if m.RuntimeData != nil {
l = m.RuntimeData.Size()
n += 1 + l + sovShim(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 + sovShim(uint64(l)) n += 1 + l + sovShim(uint64(l))
} }
@ -1866,33 +1809,22 @@ func (this *CloseStdinRequest) 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_protobuf.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
@ -3574,7 +3506,7 @@ func (m *CloseStdinRequest) 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 {
@ -3597,10 +3529,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:
@ -3653,7 +3585,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 {
@ -3676,34 +3608,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 ErrIntOverflowShim
}
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 {
@ -3727,91 +3640,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_protobuf.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 := skipShim(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthShim
}
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 ErrIntOverflowShim
}
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 ErrIntOverflowShim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthShim
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
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
@ -3946,67 +3776,65 @@ func init() {
} }
var fileDescriptorShim = []byte{ var fileDescriptorShim = []byte{
// 983 bytes of a gzipped FileDescriptorProto // 951 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x55, 0xcd, 0x6f, 0xe3, 0x44, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x55, 0xcf, 0x6f, 0xe3, 0x44,
0x14, 0xaf, 0x93, 0xd4, 0x4d, 0x5f, 0xea, 0x2e, 0x8c, 0xaa, 0xca, 0x9b, 0xa2, 0xa4, 0x18, 0x01, 0x14, 0x5e, 0x27, 0xa9, 0x9b, 0xbe, 0xac, 0xbb, 0xbb, 0xa3, 0xaa, 0xf2, 0xa6, 0x28, 0x29, 0x96,
0xdd, 0x45, 0x72, 0xa0, 0x7b, 0x40, 0x42, 0xec, 0xa1, 0xdd, 0x14, 0xb1, 0xb0, 0x88, 0x68, 0xba, 0x10, 0xd9, 0x22, 0x1c, 0xc8, 0xde, 0x10, 0x1c, 0xda, 0x6d, 0x11, 0x0b, 0x8b, 0x88, 0xa6, 0x7b,
0x9c, 0x90, 0xa8, 0xdc, 0x78, 0x9a, 0x8c, 0x64, 0x7b, 0x8c, 0x67, 0x5c, 0x36, 0x37, 0xce, 0x9c, 0x43, 0xa2, 0x72, 0x93, 0x69, 0x32, 0xc8, 0xf6, 0x18, 0xcf, 0xb8, 0x6c, 0x6e, 0x9c, 0x39, 0x71,
0xb8, 0xf2, 0xef, 0x70, 0xea, 0x81, 0x03, 0x47, 0x4e, 0x0b, 0x9b, 0xbf, 0x04, 0xcd, 0x87, 0xf3, 0xe5, 0xdf, 0xe1, 0xd4, 0x23, 0x47, 0x4e, 0x0b, 0xcd, 0x5f, 0x82, 0xe6, 0x87, 0x9d, 0xa4, 0xa9,
0xd1, 0xc6, 0x71, 0xf7, 0x62, 0xcd, 0x3c, 0xff, 0xe6, 0xcd, 0xef, 0xfd, 0xde, 0xc7, 0xc0, 0xd3, 0x93, 0xf4, 0x62, 0xcd, 0x7b, 0xfe, 0x66, 0xe6, 0x7b, 0xdf, 0xfb, 0x31, 0xf0, 0xd5, 0x88, 0x8a,
0x11, 0x15, 0xe3, 0xfc, 0xd2, 0x1f, 0xb2, 0xb8, 0x37, 0x64, 0x89, 0x08, 0x68, 0x42, 0xb2, 0x70, 0x71, 0x76, 0xe9, 0x0f, 0x58, 0xd4, 0x1d, 0xb0, 0x58, 0x04, 0x34, 0x26, 0xe9, 0x70, 0x7e, 0x19,
0x71, 0x19, 0xa4, 0xb4, 0xc7, 0x49, 0x76, 0x4d, 0x87, 0x84, 0xf7, 0xf8, 0x98, 0xc6, 0xea, 0xe3, 0x24, 0xb4, 0xcb, 0x49, 0x7a, 0x4d, 0x07, 0x84, 0x77, 0xf9, 0x98, 0x46, 0xea, 0xe3, 0x27, 0x29,
0xa7, 0x19, 0x13, 0x0c, 0x1d, 0xcc, 0x81, 0xfe, 0xf5, 0x67, 0x7e, 0x81, 0xf3, 0x25, 0xa4, 0xfd, 0x13, 0x0c, 0x1d, 0xcc, 0x80, 0xfe, 0xf5, 0xe7, 0x7e, 0x8e, 0xf3, 0x25, 0xa4, 0xf9, 0x7c, 0xc4,
0x70, 0xc4, 0xd8, 0x28, 0x22, 0x3d, 0x05, 0xbd, 0xcc, 0xaf, 0x7a, 0x41, 0x32, 0xd1, 0xe7, 0xda, 0xd8, 0x28, 0x24, 0x5d, 0x05, 0xbd, 0xcc, 0xae, 0xba, 0x41, 0x3c, 0xd1, 0xfb, 0x9a, 0x07, 0x77,
0x07, 0xb7, 0x7f, 0x91, 0x38, 0x15, 0xc5, 0xcf, 0xbd, 0x11, 0x1b, 0x31, 0xb5, 0xec, 0xc9, 0x95, 0x7f, 0x91, 0x28, 0x11, 0xf9, 0xcf, 0xbd, 0x11, 0x1b, 0x31, 0xb5, 0xec, 0xca, 0x95, 0xf1, 0x7e,
0xb1, 0x7e, 0x79, 0x2f, 0xa6, 0x62, 0x92, 0x12, 0xde, 0x8b, 0x59, 0x9e, 0x08, 0xfd, 0x35, 0xa7, 0xb9, 0x11, 0x53, 0x31, 0x49, 0x08, 0xef, 0x46, 0x2c, 0x8b, 0x85, 0xfe, 0x9a, 0xdd, 0xa7, 0x0f,
0xfb, 0x6f, 0x71, 0x7a, 0x66, 0x9c, 0xaf, 0x8c, 0x97, 0xee, 0x6d, 0xda, 0x82, 0xc6, 0x84, 0x8b, 0xd8, 0x5d, 0x38, 0x67, 0x2b, 0x73, 0x4a, 0xfb, 0x2e, 0x6d, 0x41, 0x23, 0xc2, 0x45, 0x10, 0x25,
0x20, 0x4e, 0x35, 0xc0, 0xfb, 0xad, 0x06, 0xce, 0xb3, 0x8c, 0x04, 0x82, 0x60, 0xf2, 0x73, 0x4e, 0x1a, 0xe0, 0xfd, 0x5e, 0x01, 0xe7, 0x55, 0x4a, 0x02, 0x41, 0x30, 0xf9, 0x25, 0x23, 0x5c, 0xa0,
0xb8, 0x40, 0xfb, 0x50, 0xa3, 0xa1, 0x6b, 0x1d, 0x5a, 0x47, 0xdb, 0xa7, 0xf6, 0xf4, 0x75, 0xb7, 0x7d, 0xa8, 0xd0, 0xa1, 0x6b, 0x1d, 0x5a, 0x9d, 0x9d, 0x13, 0x7b, 0xfa, 0xbe, 0x5d, 0x79, 0x7d,
0xf6, 0xbc, 0x8f, 0x6b, 0x34, 0x44, 0xfb, 0x60, 0x5f, 0xe6, 0x49, 0x18, 0x11, 0xb7, 0x26, 0xff, 0x8a, 0x2b, 0x74, 0x88, 0xf6, 0xc1, 0xbe, 0xcc, 0xe2, 0x61, 0x48, 0xdc, 0x8a, 0xfc, 0x87, 0x8d,
0x61, 0xb3, 0x43, 0x2e, 0x6c, 0x65, 0x79, 0x22, 0xfd, 0xba, 0x75, 0xf5, 0xa3, 0xd8, 0xa2, 0x87, 0x85, 0x5c, 0xd8, 0x4e, 0xb3, 0x58, 0x9e, 0xeb, 0x56, 0xd5, 0x8f, 0xdc, 0x44, 0xcf, 0xa1, 0x1e,
0xd0, 0x4c, 0xd8, 0x45, 0x4a, 0xaf, 0x99, 0x70, 0x1b, 0x87, 0xd6, 0x51, 0x13, 0x6f, 0x25, 0x6c, 0xb3, 0x8b, 0x84, 0x5e, 0x33, 0xe1, 0xd6, 0x0e, 0xad, 0x4e, 0x1d, 0x6f, 0xc7, 0xac, 0x2f, 0x4d,
0x20, 0xb7, 0xa8, 0x0d, 0x4d, 0x41, 0xb2, 0x98, 0x26, 0x41, 0xe4, 0x6e, 0xaa, 0x5f, 0xb3, 0x3d, 0xd4, 0x84, 0xba, 0x20, 0x69, 0x44, 0xe3, 0x20, 0x74, 0xb7, 0xd4, 0xaf, 0xc2, 0x46, 0x7b, 0xb0,
0xda, 0x83, 0x4d, 0x2e, 0x42, 0x9a, 0xb8, 0xb6, 0x72, 0xa7, 0x37, 0xf2, 0x7a, 0x2e, 0x42, 0x96, 0xc5, 0xc5, 0x90, 0xc6, 0xae, 0xad, 0x8e, 0xd3, 0x86, 0xbc, 0x9e, 0x8b, 0x21, 0xcb, 0x84, 0xbb,
0x0b, 0x77, 0x4b, 0x5f, 0xaf, 0x77, 0xc6, 0x4e, 0xb2, 0xcc, 0x6d, 0xce, 0xec, 0x24, 0xcb, 0xd0, 0xad, 0xaf, 0xd7, 0x96, 0xf1, 0x93, 0x34, 0x75, 0xeb, 0x85, 0x9f, 0xa4, 0x29, 0xea, 0x81, 0x9d,
0x31, 0xd8, 0x19, 0x63, 0xe2, 0x8a, 0xbb, 0xdb, 0x87, 0xf5, 0xa3, 0xd6, 0x71, 0xdb, 0x5f, 0xce, 0x32, 0x26, 0xae, 0xb8, 0xbb, 0x73, 0x58, 0xed, 0x34, 0x7a, 0x4d, 0x7f, 0x31, 0xf3, 0x4a, 0x39,
0xbc, 0x52, 0xce, 0xff, 0x4e, 0x2a, 0x8e, 0x0d, 0xd2, 0xf3, 0x60, 0xb7, 0xd0, 0x82, 0xa7, 0x2c, 0xff, 0x7b, 0xa9, 0x38, 0x36, 0x48, 0xcf, 0x83, 0xdd, 0x5c, 0x0b, 0x9e, 0xb0, 0x98, 0x13, 0xf4,
0xe1, 0x04, 0xbd, 0x03, 0xf5, 0xd4, 0xa8, 0xe1, 0x60, 0xb9, 0xf4, 0x76, 0x61, 0xe7, 0x5c, 0x04, 0x14, 0xaa, 0x89, 0x51, 0xc3, 0xc1, 0x72, 0xe9, 0xed, 0xc2, 0xe3, 0x73, 0x11, 0xa4, 0xc2, 0xc8,
0x99, 0x30, 0x72, 0x79, 0xef, 0x83, 0xd3, 0x27, 0x11, 0x99, 0xeb, 0x77, 0xf7, 0x88, 0x80, 0xdd, 0xe5, 0x7d, 0x08, 0xce, 0x29, 0x09, 0xc9, 0x4c, 0xbf, 0xe5, 0x2d, 0x02, 0x76, 0x73, 0x88, 0x39,
0x02, 0x62, 0xdc, 0x76, 0xa1, 0x45, 0x5e, 0x51, 0x71, 0xc1, 0x45, 0x20, 0x72, 0x6e, 0xb0, 0x20, 0xb6, 0x0d, 0x0d, 0xf2, 0x8e, 0x8a, 0x0b, 0x2e, 0x02, 0x91, 0x71, 0x83, 0x05, 0xe9, 0x3a, 0x57,
0x4d, 0xe7, 0xca, 0x82, 0x4e, 0x60, 0x5b, 0xee, 0x48, 0x78, 0x11, 0x08, 0xa5, 0xb7, 0x0c, 0x40, 0x1e, 0x74, 0x0c, 0x3b, 0xd2, 0x22, 0xc3, 0x8b, 0x40, 0x28, 0xbd, 0x65, 0x00, 0x3a, 0x97, 0x7e,
0xe7, 0xd2, 0x2f, 0x72, 0xe9, 0xbf, 0x2c, 0x72, 0x79, 0xda, 0xbc, 0x79, 0xdd, 0xdd, 0xf8, 0xfd, 0x9e, 0x4b, 0xff, 0x6d, 0x9e, 0xcb, 0x93, 0xfa, 0xcd, 0xfb, 0xf6, 0xa3, 0x3f, 0xfe, 0x6d, 0x5b,
0xdf, 0xae, 0x85, 0x9b, 0xfa, 0xd8, 0x89, 0xf0, 0xfe, 0xb0, 0xa0, 0x75, 0xf6, 0x8a, 0x0c, 0x0b, 0xb8, 0xae, 0xb7, 0x1d, 0x0b, 0xef, 0x4f, 0x0b, 0x1a, 0x67, 0xef, 0xc8, 0x20, 0xe7, 0x35, 0x2f,
0x5e, 0x8b, 0x92, 0x5b, 0x65, 0x92, 0xd7, 0x56, 0x4b, 0x5e, 0x2f, 0x91, 0xbc, 0xb1, 0x24, 0xf9, 0xb9, 0x55, 0x26, 0x79, 0xe5, 0x7e, 0xc9, 0xab, 0x25, 0x92, 0xd7, 0x16, 0x24, 0xef, 0x40, 0x8d,
0x11, 0x34, 0x78, 0x4a, 0x86, 0x2a, 0xa1, 0xad, 0xe3, 0xbd, 0x3b, 0x7c, 0x4f, 0x92, 0x09, 0x56, 0x27, 0x64, 0xa0, 0x12, 0xda, 0xe8, 0xed, 0x2d, 0xf1, 0x3d, 0x8e, 0x27, 0x58, 0x21, 0xbc, 0x53,
0x08, 0xaf, 0x0f, 0x36, 0x8e, 0x68, 0x4c, 0x05, 0x42, 0xd0, 0x90, 0x99, 0xd0, 0xf5, 0x86, 0xd5, 0xb0, 0x71, 0x48, 0x23, 0x2a, 0x10, 0x82, 0x9a, 0xcc, 0x84, 0xae, 0x37, 0xac, 0xd6, 0xd2, 0x37,
0x5a, 0xda, 0xc6, 0x41, 0x16, 0x2a, 0x32, 0x0d, 0xac, 0xd6, 0xd2, 0xc6, 0xd9, 0x95, 0x66, 0xd2, 0x0e, 0xd2, 0xa1, 0x22, 0x53, 0xc3, 0x6a, 0x2d, 0x7d, 0x9c, 0x5d, 0x69, 0x26, 0x35, 0xac, 0xd6,
0xc0, 0x6a, 0xed, 0x1d, 0xc2, 0x8e, 0x0e, 0xb0, 0x34, 0x59, 0x2f, 0x00, 0x06, 0x62, 0x52, 0x9a, 0xde, 0x21, 0x3c, 0xd6, 0x01, 0x96, 0x26, 0xeb, 0x0d, 0x40, 0x5f, 0x4c, 0x4a, 0x33, 0x23, 0xe3,
0x19, 0x19, 0xf7, 0x2f, 0x34, 0x14, 0x63, 0x75, 0x95, 0x83, 0xf5, 0x46, 0xc6, 0x37, 0x26, 0x74, 0xfe, 0x95, 0x0e, 0xc5, 0x58, 0x5d, 0xe5, 0x60, 0x6d, 0xc8, 0xf8, 0xc6, 0x84, 0x8e, 0xc6, 0xfa,
0x34, 0xd6, 0xb7, 0x39, 0xd8, 0xec, 0xbc, 0x07, 0xe0, 0x9c, 0x5d, 0x93, 0x44, 0xf0, 0x22, 0xf7, 0x36, 0x07, 0x1b, 0xcb, 0x7b, 0x02, 0xce, 0xd9, 0x35, 0x89, 0x05, 0xcf, 0x73, 0xaf, 0x6b, 0xa1,
0xba, 0x16, 0x66, 0xa9, 0xf7, 0xfe, 0xb4, 0xc0, 0x31, 0x06, 0x43, 0xe9, 0x6d, 0x9b, 0xc9, 0x50, 0x48, 0xbd, 0xf7, 0x97, 0x05, 0x8e, 0x71, 0x18, 0x4a, 0x0f, 0x6d, 0x26, 0x43, 0xb1, 0x3a, 0xa3,
0xac, 0xcf, 0x29, 0x3e, 0x91, 0x62, 0xab, 0x2a, 0x91, 0x62, 0xef, 0x1e, 0x1f, 0xac, 0xac, 0x63, 0xf8, 0x52, 0x8a, 0xad, 0xaa, 0x44, 0x8a, 0xbd, 0xdb, 0x3b, 0xb8, 0xb7, 0x8e, 0x75, 0xd9, 0x60,
0x5d, 0x36, 0xd8, 0x40, 0xd1, 0x17, 0xb0, 0x9d, 0x66, 0x6c, 0x48, 0x38, 0x27, 0xdc, 0xdd, 0x54, 0x03, 0x45, 0x5f, 0xc0, 0x4e, 0x92, 0xb2, 0x01, 0xe1, 0x9c, 0x70, 0x77, 0x4b, 0xd5, 0xff, 0x07,
0xf5, 0xff, 0xde, 0xca, 0x73, 0x03, 0x8d, 0xc2, 0x73, 0xb8, 0x0c, 0x6a, 0x10, 0xe4, 0x7c, 0x16, 0xf7, 0xee, 0xeb, 0x6b, 0x14, 0x9e, 0xc1, 0x65, 0x50, 0xfd, 0x20, 0xe3, 0x45, 0x50, 0x4f, 0xc0,
0xd4, 0x03, 0x70, 0x30, 0xe1, 0x79, 0x3c, 0x33, 0x38, 0xb2, 0xae, 0xe8, 0xac, 0x01, 0x9e, 0x43, 0xc1, 0x84, 0x67, 0x51, 0xe1, 0x70, 0x64, 0x5d, 0xd1, 0xa2, 0x01, 0x5e, 0x43, 0xe3, 0x3b, 0x1a,
0xeb, 0x5b, 0x1a, 0x45, 0xf3, 0xf1, 0x61, 0x73, 0x3a, 0x2a, 0x8a, 0xcc, 0xc1, 0x66, 0x27, 0x23, 0x86, 0xb3, 0xf1, 0x61, 0x73, 0x3a, 0xca, 0x8b, 0xcc, 0xc1, 0xc6, 0x92, 0x91, 0x05, 0x61, 0xa8,
0x0b, 0xa2, 0x48, 0x85, 0xdb, 0xc4, 0x72, 0x79, 0x37, 0x56, 0xef, 0x43, 0x78, 0xf7, 0x59, 0xc4, 0xc2, 0xad, 0x63, 0xb9, 0x5c, 0x8e, 0xd5, 0xfb, 0x08, 0x9e, 0xbd, 0x0a, 0x19, 0x27, 0xe7, 0xb2,
0x38, 0x39, 0x97, 0xe5, 0x57, 0xde, 0x4f, 0x1f, 0xc0, 0xf6, 0x80, 0x57, 0x8c, 0x2b, 0xef, 0x7b, 0xfc, 0xca, 0xfb, 0xe9, 0x08, 0x9e, 0xf6, 0x73, 0xba, 0x6b, 0xa6, 0x96, 0xf7, 0x03, 0x3c, 0x9b,
0xa8, 0x0d, 0xf8, 0x8a, 0x94, 0x7f, 0x0e, 0x3b, 0x66, 0x3e, 0x5d, 0x84, 0x81, 0x08, 0x4c, 0x73, 0xc3, 0x9a, 0xac, 0x2c, 0xc8, 0x63, 0x3d, 0x48, 0x9e, 0xde, 0x6d, 0x1d, 0x6a, 0xe7, 0x63, 0x1a,
0xad, 0x2e, 0xd6, 0x96, 0x41, 0xf6, 0x03, 0x11, 0x78, 0x4f, 0x01, 0xe4, 0xad, 0x26, 0xb1, 0x3d, 0xa1, 0x00, 0x6c, 0x3d, 0x2c, 0xd0, 0x91, 0xbf, 0xe2, 0x51, 0xf1, 0x17, 0xa6, 0x6b, 0xf3, 0x93,
0xa8, 0xa5, 0xb2, 0x71, 0xa5, 0xb4, 0x5d, 0x7f, 0xcd, 0xa3, 0xe2, 0x0f, 0x38, 0xae, 0xa5, 0xfc, 0x8d, 0xb0, 0x86, 0xe7, 0xb7, 0xb0, 0xa5, 0x66, 0x0d, 0x7a, 0xb1, 0x72, 0xd7, 0xfc, 0x3c, 0x6a,
0xf8, 0xaf, 0x26, 0x34, 0xce, 0xc7, 0x34, 0x46, 0x01, 0xd8, 0x7a, 0xc8, 0xa0, 0xc7, 0x6b, 0xcf, 0xee, 0x2f, 0xb5, 0xdd, 0x99, 0x7c, 0xa9, 0x24, 0x5d, 0x3d, 0x84, 0xd6, 0xd0, 0x5d, 0x18, 0x66,
0x2d, 0x4d, 0xe5, 0xf6, 0x27, 0xf7, 0xc2, 0x1a, 0x72, 0xdf, 0xc0, 0xa6, 0x9a, 0x51, 0xe8, 0xd1, 0x6b, 0xe8, 0xde, 0x99, 0x6a, 0x3f, 0x29, 0xba, 0x82, 0xac, 0xa7, 0x3b, 0xbb, 0xe0, 0x68, 0x13,
0xda, 0x53, 0x8b, 0x73, 0xac, 0xbd, 0x7f, 0x47, 0x81, 0x33, 0xf9, 0xc2, 0x49, 0xba, 0x7a, 0x78, 0xa8, 0x39, 0xff, 0x67, 0xd8, 0x29, 0x72, 0x89, 0x3e, 0x5d, 0xb9, 0xf1, 0x6e, 0x7d, 0x34, 0xfd,
0x55, 0xd0, 0x5d, 0x1a, 0x82, 0x15, 0x74, 0x6f, 0x4d, 0xc3, 0x9f, 0x14, 0x5d, 0x41, 0xaa, 0xe9, 0x4d, 0xe1, 0x33, 0xe9, 0x55, 0x17, 0xac, 0x89, 0x65, 0xbe, 0x53, 0x4a, 0xa5, 0x7f, 0x03, 0xb6,
0xce, 0x2f, 0x78, 0x7c, 0x1f, 0xa8, 0xf1, 0xff, 0x83, 0x2a, 0x85, 0x8f, 0xaa, 0xb2, 0x64, 0x3c, 0xee, 0xa0, 0x35, 0xd2, 0x2f, 0xb4, 0x59, 0xe9, 0x69, 0xdf, 0x40, 0x4d, 0xb6, 0x1f, 0xea, 0xac,
0x7f, 0x5c, 0x89, 0x9b, 0xab, 0xac, 0x1a, 0xa5, 0x82, 0xf6, 0x62, 0x33, 0x95, 0xaa, 0xfc, 0x02, 0x3c, 0x6b, 0xae, 0x43, 0x4b, 0x4f, 0xc2, 0x60, 0xeb, 0x79, 0xb6, 0x86, 0xd7, 0xc2, 0xd0, 0x6b,
0x6c, 0xdd, 0x64, 0x15, 0x2a, 0x2f, 0x75, 0x62, 0xa9, 0xb7, 0xaf, 0xa1, 0x21, 0x3b, 0x14, 0x1d, 0xde, 0xff, 0x90, 0x2a, 0xcc, 0x67, 0x96, 0x64, 0x27, 0xa7, 0xc1, 0x1a, 0x76, 0x73, 0x03, 0xa3,
0xad, 0xf5, 0xb5, 0xd0, 0xc4, 0xa5, 0x9e, 0x30, 0xd8, 0x7a, 0xe4, 0x55, 0xf0, 0x5a, 0x9a, 0x8b, 0x94, 0xdd, 0x8f, 0x32, 0x4e, 0x32, 0x58, 0x1b, 0x67, 0xf1, 0xc2, 0x35, 0x5f, 0x6c, 0x80, 0x34,
0xed, 0xd5, 0x6f, 0xad, 0xc2, 0x7c, 0x6a, 0x49, 0x76, 0x72, 0x60, 0x54, 0xb0, 0x5b, 0x98, 0x29, 0xe9, 0xfd, 0x1a, 0xaa, 0x7d, 0x31, 0x41, 0x1f, 0xaf, 0x4e, 0x6e, 0xf1, 0x74, 0x94, 0x92, 0x7c,
0xa5, 0xec, 0x7e, 0x94, 0x71, 0x92, 0x61, 0x65, 0x9c, 0xb3, 0x47, 0xb0, 0xfd, 0xe8, 0x1e, 0x48, 0x0b, 0x30, 0x9b, 0x58, 0x68, 0x75, 0x91, 0x2d, 0x8d, 0xb6, 0xb2, 0x53, 0x4f, 0xdc, 0x9b, 0xdb,
0x93, 0xde, 0xaf, 0xa0, 0x3e, 0x10, 0x13, 0x54, 0x51, 0x0e, 0xb3, 0xd7, 0xa5, 0x94, 0xe4, 0x4b, 0xd6, 0xa3, 0x7f, 0x6e, 0x5b, 0x8f, 0x7e, 0x9b, 0xb6, 0xac, 0x9b, 0x69, 0xcb, 0xfa, 0x7b, 0xda,
0x80, 0xf9, 0x50, 0x43, 0xfe, 0xfa, 0x3e, 0xbe, 0x3d, 0xfd, 0xca, 0xbc, 0x9e, 0xba, 0x37, 0x6f, 0xb2, 0xfe, 0x9b, 0xb6, 0xac, 0x4b, 0x5b, 0x21, 0x5f, 0xfe, 0x1f, 0x00, 0x00, 0xff, 0xff, 0x26,
0x3a, 0x1b, 0xff, 0xbc, 0xe9, 0x6c, 0xfc, 0x3a, 0xed, 0x58, 0x37, 0xd3, 0x8e, 0xf5, 0xf7, 0xb4, 0xfb, 0xd6, 0x0f, 0x06, 0x0b, 0x00, 0x00,
0x63, 0xfd, 0x37, 0xed, 0x58, 0x97, 0xb6, 0x42, 0x3e, 0xf9, 0x3f, 0x00, 0x00, 0xff, 0xff, 0x7a,
0x10, 0xcb, 0x24, 0x29, 0x0b, 0x00, 0x00,
} }

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

@ -18,7 +18,7 @@ service Shim {
rpc Start(StartRequest) returns (google.protobuf.Empty); rpc Start(StartRequest) returns (google.protobuf.Empty);
rpc Delete(DeleteRequest) returns (DeleteResponse); rpc Delete(DeleteRequest) returns (DeleteResponse);
rpc State(StateRequest) returns (StateResponse); rpc State(StateRequest) returns (StateResponse);
rpc Ps(PsRequest) returns (PsResponse); rpc Processes(ProcessesRequest) returns (ProcessesResponse);
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);
@ -115,15 +115,10 @@ message CloseStdinRequest {
uint32 pid = 1; uint32 pid = 1;
} }
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;
} }

2
cmd/ctr/ps.go
View File

@ -48,10 +48,10 @@ var psCommand = cli.Command{
); err != nil { ); err != nil {
return err return err
} }
}
if err := w.Flush(); err != nil { if err := w.Flush(); err != nil {
return err return err
} }
}
return nil return nil
}, },

8
linux/container.go
View File

@ -114,8 +114,8 @@ func (c *Container) Exec(ctx context.Context, opts plugin.ExecOpts) (plugin.Proc
}, nil }, nil
} }
func (c *Container) Ps(ctx context.Context) ([]uint32, error) { func (c *Container) Processes(ctx context.Context) ([]uint32, error) {
resp, err := c.shim.Ps(ctx, &shim.PsRequest{ resp, err := c.shim.Processes(ctx, &shim.ProcessesRequest{
ID: c.id, ID: c.id,
}) })
@ -123,9 +123,9 @@ func (c *Container) Ps(ctx context.Context) ([]uint32, error) {
return nil, err return nil, err
} }
pids := make([]uint32, 0, len(resp.Ps)) pids := make([]uint32, 0, len(resp.Processes))
for _, ps := range resp.Ps { for _, ps := range resp.Processes {
pids = append(pids, ps.Pid) pids = append(pids, ps.Pid)
} }

4
linux/shim/client.go
View File

@ -82,8 +82,8 @@ func (c *client) Kill(ctx context.Context, in *shimapi.KillRequest, opts ...grpc
return c.s.Kill(ctx, in) return c.s.Kill(ctx, in)
} }
func (c *client) Ps(ctx context.Context, in *shimapi.PsRequest, opts ...grpc.CallOption) (*shimapi.PsResponse, error) { func (c *client) Processes(ctx context.Context, in *shimapi.ProcessesRequest, opts ...grpc.CallOption) (*shimapi.ProcessesResponse, error) {
return c.s.Ps(ctx, in) return c.s.Processes(ctx, in)
} }
func (c *client) Exit(ctx context.Context, in *shimapi.ExitRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error) { func (c *client) Exit(ctx context.Context, in *shimapi.ExitRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {

10
linux/shim/service.go
View File

@ -250,20 +250,20 @@ func (s *Service) Kill(ctx context.Context, r *shimapi.KillRequest) (*google_pro
return empty, nil return empty, nil
} }
func (s *Service) Ps(ctx context.Context, r *shimapi.PsRequest) (*shimapi.PsResponse, error) { func (s *Service) Processes(ctx context.Context, r *shimapi.ProcessesRequest) (*shimapi.ProcessesResponse, error) {
pids, err := s.getContainerPids(ctx, r.ID) pids, err := s.getContainerPids(ctx, r.ID)
if err != nil { if err != nil {
return nil, err return nil, err
} }
ps := []*shimapi.Ps{} ps := []*container.Process{}
for _, pid := range pids { for _, pid := range pids {
ps = append(ps, &shimapi.Ps{ ps = append(ps, &container.Process{
Pid: pid, Pid: pid,
}) })
} }
resp := &shimapi.PsResponse{ resp := &shimapi.ProcessesResponse{
Ps: ps, Processes: ps,
} }
return resp, nil return resp, nil

4
plugin/container.go
View File

@ -22,8 +22,8 @@ type Container interface {
Kill(context.Context, uint32, uint32, bool) error Kill(context.Context, uint32, uint32, bool) error
// Exec adds a process into the container // Exec adds a process into the container
Exec(context.Context, ExecOpts) (Process, error) Exec(context.Context, ExecOpts) (Process, error)
// Ps returns all pids for the container // Processes returns all pids for the container
Ps(context.Context) ([]uint32, error) Processes(context.Context) ([]uint32, error)
// Pty resizes the processes pty/console // Pty resizes the processes pty/console
Pty(context.Context, uint32, ConsoleSize) error Pty(context.Context, uint32, ConsoleSize) error
// CloseStdin closes the processes stdin // CloseStdin closes the processes stdin

2
services/execution/service.go
View File

@ -240,7 +240,7 @@ func (s *Service) Processes(ctx context.Context, r *api.ProcessesRequest) (*api.
return nil, err return nil, err
} }
pids, err := c.Ps(ctx) pids, err := c.Processes(ctx)
if err != nil { if err != nil {
return nil, err return nil, err
} }

2
windows/container.go
View File

@ -174,7 +174,7 @@ func (c *container) Pid() uint32 {
return c.ctr.Pid() return c.ctr.Pid()
} }
func (c *container) Ps(ctx context.Context) ([]uint32, error) { func (c *container) Processes(ctx context.Context) ([]uint32, error) {
// TODO (ehazlett): support finding all processes in windows container // TODO (ehazlett): support finding all processes in windows container
p, err := c.ctr.ProcessList() p, err := c.ctr.ProcessList()
if err != nil { if err != nil {