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

expose exec-id on ctr task ps

Browse Source 
Signed-off-by: Jess Valarezo <valarezo.jessica@gmail.com>
This commit is contained in:
Jess Valarezo 2017-11-03 14:49:47 -07:00
parent b4a65de5c6
commit 807f4d2ec7
12 changed files with 319 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
cmd/ctr/commands/tasks/ps.go
View File

@ -6,7 +6,7 @@ import (
"text/tabwriter"
"github.com/containerd/containerd/cmd/ctr/commands"
"github.com/containerd/containerd/windows/hcsshimtypes"
"github.com/containerd/typeurl"
"github.com/pkg/errors"
"github.com/urfave/cli"
)
@ -29,7 +29,6 @@ var psCommand = cli.Command{
if err != nil {
return err
}
task, err := container.Task(ctx, nil)
if err != nil {
return err
@ -38,22 +37,20 @@ var psCommand = cli.Command{
if err != nil {
return err
}
w := tabwriter.NewWriter(os.Stdout, 10, 1, 3, ' ', 0)
w := tabwriter.NewWriter(os.Stdout, 1, 8, 4, ' ', 0)
fmt.Fprintln(w, "PID\tINFO")
for _, ps := range processes {
var info interface{} = "-"
if ps.Info != nil {
var details hcsshimtypes.ProcessDetails
if err := details.Unmarshal(ps.Info.Value); err == nil {
if _, err := fmt.Fprintf(w, "%d\t%+v\n", ps.Pid, details); err != nil {
info, err = typeurl.UnmarshalAny(ps.Info)
if err != nil {
return err
}
}
} else {
if _, err := fmt.Fprintf(w, "%d\t-\n", ps.Pid); err != nil {
if _, err := fmt.Fprintf(w, "%d\t%+v\n", ps.Pid, info); err != nil {
return err
}
}
}
return w.Flush()
},
}

10
linux/runcopts/next.pb.txt
View File

@ -165,6 +165,16 @@ file {
json_name: "cgroupsMode"
}
}
message_type {
name: "ProcessDetails"
field {
name: "exec_id"
number: 1
label: LABEL_OPTIONAL
type: TYPE_STRING
json_name: "execId"
}
}
options {
go_package: "github.com/containerd/containerd/linux/runcopts;runcopts"
}

200
linux/runcopts/runc.pb.go
View File

@ -11,6 +11,7 @@
RuncOptions
CreateOptions
CheckpointOptions
ProcessDetails
*/
package runcopts
@ -78,10 +79,19 @@ func (m *CheckpointOptions) Reset() { *m = CheckpointOptions{
func (*CheckpointOptions) ProtoMessage() {}
func (*CheckpointOptions) Descriptor() ([]byte, []int) { return fileDescriptorRunc, []int{2} }
type ProcessDetails struct {
ExecID string `protobuf:"bytes,1,opt,name=exec_id,json=execId,proto3" json:"exec_id,omitempty"`
}
func (m *ProcessDetails) Reset() { *m = ProcessDetails{} }
func (*ProcessDetails) ProtoMessage() {}
func (*ProcessDetails) Descriptor() ([]byte, []int) { return fileDescriptorRunc, []int{3} }
func init() {
proto.RegisterType((*RuncOptions)(nil), "containerd.linux.runc.RuncOptions")
proto.RegisterType((*CreateOptions)(nil), "containerd.linux.runc.CreateOptions")
proto.RegisterType((*CheckpointOptions)(nil), "containerd.linux.runc.CheckpointOptions")
proto.RegisterType((*ProcessDetails)(nil), "containerd.linux.runc.ProcessDetails")
}
func (m *RuncOptions) Marshal() (dAtA []byte, err error) {
size := m.Size()
@ -333,6 +343,30 @@ func (m *CheckpointOptions) MarshalTo(dAtA []byte) (int, error) {
return i, nil
}
func (m *ProcessDetails) 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 *ProcessDetails) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.ExecID) > 0 {
dAtA[i] = 0xa
i++
i = encodeVarintRunc(dAtA, i, uint64(len(m.ExecID)))
i += copy(dAtA[i:], m.ExecID)
}
return i, nil
}
func encodeVarintRunc(dAtA []byte, offset int, v uint64) int {
for v >= 1<<7 {
dAtA[offset] = uint8(v&0x7f | 0x80)
@ -438,6 +472,16 @@ func (m *CheckpointOptions) Size() (n int) {
return n
}
func (m *ProcessDetails) Size() (n int) {
var l int
_ = l
l = len(m.ExecID)
if l > 0 {
n += 1 + l + sovRunc(uint64(l))
}
return n
}
func sovRunc(x uint64) (n int) {
for {
n++
@ -500,6 +544,16 @@ func (this *CheckpointOptions) String() string {
}, "")
return s
}
func (this *ProcessDetails) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&ProcessDetails{`,
`ExecID:` + fmt.Sprintf("%v", this.ExecID) + `,`,
`}`,
}, "")
return s
}
func valueToStringRunc(v interface{}) string {
rv := reflect.ValueOf(v)
if rv.IsNil() {
@ -1168,6 +1222,85 @@ func (m *CheckpointOptions) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *ProcessDetails) 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 ErrIntOverflowRunc
}
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: ProcessDetails: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: ProcessDetails: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ExecID", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowRunc
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthRunc
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.ExecID = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipRunc(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthRunc
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipRunc(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0
@ -1278,36 +1411,39 @@ func init() {
}
var fileDescriptorRunc = []byte{
// 495 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x93, 0x31, 0x6f, 0xd3, 0x40,
0x14, 0xc7, 0x7b, 0xb4, 0x4d, 0x9c, 0x4b, 0x53, 0xe0, 0x20, 0xd2, 0x51, 0x84, 0x09, 0x11, 0x48,
0x61, 0x49, 0x24, 0x58, 0x10, 0x6c, 0x64, 0x60, 0x00, 0x4a, 0x65, 0xe8, 0xc2, 0x72, 0x72, 0xcf,
0x87, 0xf3, 0x94, 0xf8, 0xde, 0xe9, 0xee, 0x4c, 0x93, 0xad, 0x9f, 0x80, 0xcf, 0xd5, 0x91, 0x91,
0x91, 0xe6, 0x8b, 0x80, 0x7c, 0xb6, 0x0b, 0x2b, 0x2b, 0xdb, 0xff, 0xfd, 0xfe, 0xcf, 0x7e, 0x4f,
0xff, 0xd3, 0xa3, 0x2f, 0x73, 0xf0, 0x8b, 0xf2, 0x6c, 0x2a, 0xb1, 0x98, 0x49, 0xd4, 0x3e, 0x05,
0xad, 0x6c, 0xf6, 0xb7, 0x5c, 0x81, 0x2e, 0xd7, 0x33, 0x5b, 0x6a, 0x89, 0xc6, 0xbb, 0x20, 0xa6,
0xc6, 0xa2, 0x47, 0x36, 0xfc, 0xd3, 0x35, 0x0d, 0x5d, 0xd3, 0xca, 0x3c, 0xba, 0x9b, 0x63, 0x8e,
0xa1, 0x63, 0x56, 0xa9, 0xba, 0x79, 0xfc, 0x8d, 0xd0, 0x7e, 0x52, 0x6a, 0xf9, 0xc1, 0x78, 0x40,
0xed, 0x18, 0xa7, 0x5d, 0x5b, 0x6a, 0x0f, 0x85, 0xe2, 0x64, 0x44, 0x26, 0xbd, 0xa4, 0x2d, 0xd9,
0x23, 0x7a, 0xd0, 0x48, 0x61, 0x11, 0x3d, 0xbf, 0x11, 0xec, 0x7e, 0xc3, 0x12, 0x44, 0xcf, 0xee,
0xd3, 0x9e, 0xb4, 0x50, 0x0a, 0x93, 0xfa, 0x05, 0xdf, 0x0d, 0x7e, 0x54, 0x81, 0x93, 0xd4, 0x2f,
0xd8, 0x13, 0x7a, 0xe8, 0x36, 0xce, 0xab, 0x22, 0x13, 0x32, 0xb7, 0x58, 0x1a, 0xbe, 0x37, 0x22,
0x93, 0x28, 0x19, 0x34, 0x74, 0x1e, 0xe0, 0xf8, 0x62, 0x97, 0x0e, 0xe6, 0x56, 0xa5, 0x5e, 0xb5,
0x2b, 0x8d, 0xe9, 0x40, 0xa3, 0x30, 0xf0, 0x15, 0x7d, 0x3d, 0x99, 0x84, 0xef, 0xfa, 0x1a, 0x4f,
0x2a, 0x16, 0x26, 0xdf, 0xa3, 0x11, 0x1a, 0xa5, 0x85, 0x97, 0x26, 0x2c, 0x16, 0x25, 0xdd, 0xaa,
0xfe, 0x24, 0x0d, 0x7b, 0x46, 0x87, 0x6a, 0xed, 0x95, 0xd5, 0xe9, 0x4a, 0x94, 0x1a, 0xd6, 0xc2,
0xa1, 0x5c, 0x2a, 0xef, 0xc2, 0x82, 0x51, 0x72, 0xa7, 0x35, 0x4f, 0x35, 0xac, 0x3f, 0xd6, 0x16,
0x3b, 0xa2, 0x91, 0x57, 0xb6, 0x00, 0x9d, 0xae, 0x9a, 0x2d, 0xaf, 0x6b, 0xf6, 0x80, 0xd2, 0x2f,
0xb0, 0x52, 0x62, 0x85, 0x72, 0xe9, 0xf8, 0x7e, 0x70, 0x7b, 0x15, 0x79, 0x57, 0x01, 0xf6, 0x94,
0xde, 0x52, 0x85, 0xf1, 0x1b, 0xa1, 0xd3, 0x42, 0x39, 0x93, 0x4a, 0xe5, 0x78, 0x67, 0xb4, 0x3b,
0xe9, 0x25, 0x37, 0x03, 0x3f, 0xbe, 0xc6, 0x55, 0xa2, 0x75, 0x12, 0x4e, 0x14, 0x98, 0x29, 0xde,
0xad, 0x13, 0x6d, 0xd8, 0x7b, 0xcc, 0x14, 0x7b, 0x4c, 0x0f, 0x35, 0x0a, 0xad, 0xce, 0xc5, 0x52,
0x6d, 0x2c, 0xe8, 0x9c, 0x47, 0x61, 0xe0, 0x81, 0xc6, 0x63, 0x75, 0xfe, 0xb6, 0x66, 0xec, 0x21,
0xed, 0xbb, 0x05, 0x14, 0x6d, 0xae, 0xbd, 0xf0, 0x1f, 0x5a, 0xa1, 0x3a, 0x54, 0x36, 0xa4, 0x1d,
0x40, 0x51, 0x42, 0xc6, 0xe9, 0x88, 0x4c, 0x06, 0xc9, 0x3e, 0xe0, 0x29, 0x64, 0x0d, 0xce, 0x21,
0xe3, 0xfd, 0x16, 0xbf, 0x81, 0x6c, 0xfc, 0x8b, 0xd0, 0xdb, 0xf3, 0x85, 0x92, 0x4b, 0x83, 0xa0,
0x7d, 0xfb, 0x0c, 0x8c, 0xee, 0xa9, 0x35, 0xb4, 0xe9, 0x07, 0xfd, 0xbf, 0xc6, 0xfe, 0x3a, 0xb9,
0xbc, 0x8a, 0x77, 0x7e, 0x5c, 0xc5, 0x3b, 0x17, 0xdb, 0x98, 0x5c, 0x6e, 0x63, 0xf2, 0x7d, 0x1b,
0x93, 0x9f, 0xdb, 0x98, 0x7c, 0x7e, 0xf1, 0x8f, 0x87, 0xf9, 0xaa, 0x15, 0x67, 0x9d, 0x70, 0x70,
0xcf, 0x7f, 0x07, 0x00, 0x00, 0xff, 0xff, 0xbe, 0xbb, 0xf0, 0x6c, 0xdb, 0x03, 0x00, 0x00,
// 536 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x93, 0xc1, 0x6e, 0xd3, 0x40,
0x10, 0x86, 0x6b, 0xda, 0x26, 0xce, 0xa4, 0x29, 0xb0, 0x50, 0xc9, 0x14, 0x91, 0x86, 0x00, 0x52,
0xb8, 0xa4, 0x12, 0x08, 0x09, 0xc1, 0xad, 0x2d, 0x42, 0x15, 0x50, 0x2a, 0x43, 0x2f, 0x5c, 0x56,
0xee, 0x7a, 0x48, 0x56, 0x89, 0x77, 0x56, 0xbb, 0x6b, 0xea, 0xdc, 0xfa, 0x04, 0x3c, 0x57, 0x8f,
0x1c, 0x39, 0x21, 0x9a, 0x17, 0x01, 0x79, 0x6d, 0x17, 0xae, 0x5c, 0xb9, 0xfd, 0xf3, 0xfd, 0x63,
0xcf, 0xe8, 0x5f, 0x0d, 0xbc, 0x98, 0x48, 0x37, 0xcd, 0x4f, 0xc7, 0x82, 0xb2, 0x5d, 0x41, 0xca,
0x25, 0x52, 0xa1, 0x49, 0xff, 0x96, 0x73, 0xa9, 0xf2, 0x62, 0xd7, 0xe4, 0x4a, 0x90, 0x76, 0xd6,
0x8b, 0xb1, 0x36, 0xe4, 0x88, 0x6d, 0xfd, 0xe9, 0x1a, 0xfb, 0xae, 0x71, 0x69, 0x6e, 0xdf, 0x9e,
0xd0, 0x84, 0x7c, 0xc7, 0x6e, 0xa9, 0xaa, 0xe6, 0xe1, 0xd7, 0x00, 0xba, 0x71, 0xae, 0xc4, 0x7b,
0xed, 0x24, 0x29, 0xcb, 0x22, 0x68, 0x9b, 0x5c, 0x39, 0x99, 0x61, 0x14, 0x0c, 0x82, 0x51, 0x27,
0x6e, 0x4a, 0x76, 0x1f, 0x36, 0x6a, 0xc9, 0x0d, 0x91, 0x8b, 0xae, 0x79, 0xbb, 0x5b, 0xb3, 0x98,
0xc8, 0xb1, 0xbb, 0xd0, 0x11, 0x46, 0xe6, 0x5c, 0x27, 0x6e, 0x1a, 0xad, 0x7a, 0x3f, 0x2c, 0xc1,
0x71, 0xe2, 0xa6, 0xec, 0x11, 0x6c, 0xda, 0x85, 0x75, 0x98, 0xa5, 0x5c, 0x4c, 0x0c, 0xe5, 0x3a,
0x5a, 0x1b, 0x04, 0xa3, 0x30, 0xee, 0xd5, 0x74, 0xdf, 0xc3, 0xe1, 0xf9, 0x2a, 0xf4, 0xf6, 0x0d,
0x26, 0x0e, 0x9b, 0x95, 0x86, 0xd0, 0x53, 0xc4, 0xb5, 0xfc, 0x42, 0xae, 0x9a, 0x1c, 0xf8, 0xef,
0xba, 0x8a, 0x8e, 0x4b, 0xe6, 0x27, 0xdf, 0x81, 0x90, 0x34, 0x2a, 0xee, 0x84, 0xf6, 0x8b, 0x85,
0x71, 0xbb, 0xac, 0x3f, 0x0a, 0xcd, 0x9e, 0xc0, 0x16, 0x16, 0x0e, 0x8d, 0x4a, 0xe6, 0x3c, 0x57,
0xb2, 0xe0, 0x96, 0xc4, 0x0c, 0x9d, 0xf5, 0x0b, 0x86, 0xf1, 0xad, 0xc6, 0x3c, 0x51, 0xb2, 0xf8,
0x50, 0x59, 0x6c, 0x1b, 0x42, 0x87, 0x26, 0x93, 0x2a, 0x99, 0xd7, 0x5b, 0x5e, 0xd5, 0xec, 0x1e,
0xc0, 0x67, 0x39, 0x47, 0x3e, 0x27, 0x31, 0xb3, 0xd1, 0xba, 0x77, 0x3b, 0x25, 0x79, 0x5b, 0x02,
0xf6, 0x18, 0x6e, 0x60, 0xa6, 0xdd, 0x82, 0xab, 0x24, 0x43, 0xab, 0x13, 0x81, 0x36, 0x6a, 0x0d,
0x56, 0x47, 0x9d, 0xf8, 0xba, 0xe7, 0x47, 0x57, 0xb8, 0x4c, 0xb4, 0x4a, 0xc2, 0xf2, 0x8c, 0x52,
0x8c, 0xda, 0x55, 0xa2, 0x35, 0x7b, 0x47, 0x29, 0xb2, 0x87, 0xb0, 0xa9, 0x88, 0x2b, 0x3c, 0xe3,
0x33, 0x5c, 0x18, 0xa9, 0x26, 0x51, 0xe8, 0x07, 0x6e, 0x28, 0x3a, 0xc2, 0xb3, 0x37, 0x15, 0x63,
0x3b, 0xd0, 0xb5, 0x53, 0x99, 0x35, 0xb9, 0x76, 0xfc, 0x7f, 0xa0, 0x44, 0x55, 0xa8, 0x6c, 0x0b,
0x5a, 0x92, 0x78, 0x2e, 0xd3, 0x08, 0x06, 0xc1, 0xa8, 0x17, 0xaf, 0x4b, 0x3a, 0x91, 0x69, 0x8d,
0x27, 0x32, 0x8d, 0xba, 0x0d, 0x7e, 0x2d, 0xd3, 0xe1, 0xaf, 0x00, 0x6e, 0xee, 0x4f, 0x51, 0xcc,
0x34, 0x49, 0xe5, 0x9a, 0x67, 0x60, 0xb0, 0x86, 0x85, 0x6c, 0xd2, 0xf7, 0xfa, 0x7f, 0x8d, 0x7d,
0xf8, 0x0c, 0x36, 0x8f, 0x0d, 0x09, 0xb4, 0xf6, 0x00, 0x5d, 0x22, 0xe7, 0x96, 0x3d, 0x80, 0x36,
0x16, 0x28, 0xb8, 0x4c, 0xab, 0xbb, 0xd8, 0x83, 0xe5, 0x8f, 0x9d, 0xd6, 0xab, 0x02, 0xc5, 0xe1,
0x41, 0xdc, 0x2a, 0xad, 0xc3, 0x74, 0x2f, 0xbe, 0xb8, 0xec, 0xaf, 0x7c, 0xbf, 0xec, 0xaf, 0x9c,
0x2f, 0xfb, 0xc1, 0xc5, 0xb2, 0x1f, 0x7c, 0x5b, 0xf6, 0x83, 0x9f, 0xcb, 0x7e, 0xf0, 0xe9, 0xf9,
0x3f, 0xde, 0xf3, 0xcb, 0x46, 0x9c, 0xb6, 0xfc, 0x9d, 0x3e, 0xfd, 0x1d, 0x00, 0x00, 0xff, 0xff,
0x15, 0x0d, 0x16, 0x1d, 0x12, 0x04, 0x00, 0x00,
}

4
linux/runcopts/runc.proto
View File

@ -36,3 +36,7 @@ message CheckpointOptions {
repeated string empty_namespaces = 6;
string cgroups_mode = 7;
}
message ProcessDetails {
string exec_id = 1;
}

20
linux/shim/service.go
View File

@ -15,12 +15,14 @@ import (
"github.com/containerd/containerd/api/types/task"
"github.com/containerd/containerd/errdefs"
"github.com/containerd/containerd/events"
"github.com/containerd/containerd/linux/runcopts"
shimapi "github.com/containerd/containerd/linux/shim/v1"
"github.com/containerd/containerd/log"
"github.com/containerd/containerd/namespaces"
"github.com/containerd/containerd/reaper"
"github.com/containerd/containerd/runtime"
runc "github.com/containerd/go-runc"
"github.com/containerd/typeurl"
google_protobuf "github.com/golang/protobuf/ptypes/empty"
"github.com/pkg/errors"
"github.com/sirupsen/logrus"
@ -357,9 +359,23 @@ func (s *Service) ListPids(ctx context.Context, r *shimapi.ListPidsRequest) (*sh
}
var processes []*task.ProcessInfo
for _, pid := range pids {
processes = append(processes, &task.ProcessInfo{
pInfo := task.ProcessInfo{
Pid: pid,
})
}
for _, p := range s.processes {
if p.Pid() == int(pid) {
d := &runcopts.ProcessDetails{
ExecID: p.ID(),
}
a, err := typeurl.MarshalAny(d)
if err != nil {
return nil, errors.Wrapf(err, "failed to marshal process %d info", pid)
}
pInfo.Info = a
break
}
}
processes = append(processes, &pInfo)
}
return &shimapi.ListPidsResponse{
Processes: processes,

1
linux/task.go
View File

@ -183,6 +183,7 @@ func (t *Task) Pids(ctx context.Context) ([]runtime.ProcessInfo, error) {
for _, p := range resp.Processes {
processList = append(processList, runtime.ProcessInfo{
Pid: p.Pid,
Info: p.Info,
})
}
return processList, nil

6
services/tasks/service.go
View File

@ -348,7 +348,7 @@ func (s *service) ListPids(ctx context.Context, r *api.ListPidsRequest) (*api.Li
}
var processes []*task.ProcessInfo
for _, p := range processList {
processInfo := task.ProcessInfo{
pInfo := task.ProcessInfo{
Pid: p.Pid,
}
if p.Info != nil {
@ -356,9 +356,9 @@ func (s *service) ListPids(ctx context.Context, r *api.ListPidsRequest) (*api.Li
if err != nil {
return nil, errors.Wrapf(err, "failed to marshal process %d info", p.Pid)
}
processInfo.Info = a
pInfo.Info = a
}
processes = append(processes, &processInfo)
processes = append(processes, &pInfo)
}
return &api.ListPidsResponse{
Processes: processes,

105
windows/hcsshimtypes/hcsshim.pb.go
View File

@ -60,6 +60,7 @@ type ProcessDetails struct {
MemoryWorkingSetSharedBytes uint64 `protobuf:"varint,6,opt,name=memory_working_set_shared_bytes,json=memoryWorkingSetSharedBytes,proto3" json:"memory_working_set_shared_bytes,omitempty"`
ProcessID uint32 `protobuf:"varint,7,opt,name=process_id,json=processId,proto3" json:"process_id,omitempty"`
UserTime_100Ns uint64 `protobuf:"varint,8,opt,name=user_time_100_ns,json=userTime100Ns,proto3" json:"user_time_100_ns,omitempty"`
ExecID string `protobuf:"bytes,9,opt,name=exec_id,json=execId,proto3" json:"exec_id,omitempty"`
}
func (m *ProcessDetails) Reset() { *m = ProcessDetails{} }
@ -155,6 +156,12 @@ func (m *ProcessDetails) MarshalTo(dAtA []byte) (int, error) {
i++
i = encodeVarintHcsshim(dAtA, i, uint64(m.UserTime_100Ns))
}
if len(m.ExecID) > 0 {
dAtA[i] = 0x4a
i++
i = encodeVarintHcsshim(dAtA, i, uint64(len(m.ExecID)))
i += copy(dAtA[i:], m.ExecID)
}
return i, nil
}
@ -202,6 +209,10 @@ func (m *ProcessDetails) Size() (n int) {
if m.UserTime_100Ns != 0 {
n += 1 + sovHcsshim(uint64(m.UserTime_100Ns))
}
l = len(m.ExecID)
if l > 0 {
n += 1 + l + sovHcsshim(uint64(l))
}
return n
}
@ -241,6 +252,7 @@ func (this *ProcessDetails) String() string {
`MemoryWorkingSetSharedBytes:` + fmt.Sprintf("%v", this.MemoryWorkingSetSharedBytes) + `,`,
`ProcessID:` + fmt.Sprintf("%v", this.ProcessID) + `,`,
`UserTime_100Ns:` + fmt.Sprintf("%v", this.UserTime_100Ns) + `,`,
`ExecID:` + fmt.Sprintf("%v", this.ExecID) + `,`,
`}`,
}, "")
return s
@ -535,6 +547,35 @@ func (m *ProcessDetails) Unmarshal(dAtA []byte) error {
break
}
}
case 9:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ExecID", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowHcsshim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthHcsshim
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.ExecID = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipHcsshim(dAtA[iNdEx:])
@ -666,35 +707,37 @@ func init() {
}
var fileDescriptorHcsshim = []byte{
// 479 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x92, 0x41, 0x6f, 0xd3, 0x30,
0x14, 0xc7, 0x1b, 0x36, 0xc6, 0x62, 0x54, 0x60, 0x86, 0x43, 0x28, 0x90, 0x54, 0xbb, 0x50, 0x09,
0x94, 0x74, 0x70, 0xe4, 0x44, 0x5a, 0x21, 0xed, 0x32, 0xa6, 0x0c, 0x09, 0x09, 0x21, 0x59, 0x6e,
0xf2, 0x48, 0xad, 0xd5, 0x71, 0x64, 0xbb, 0x54, 0xbd, 0xf1, 0x11, 0x38, 0xf2, 0x49, 0xf8, 0x0c,
0x3d, 0x72, 0xe4, 0x34, 0x58, 0x3e, 0x09, 0x8a, 0xed, 0x96, 0x51, 0x38, 0x71, 0xf3, 0xf3, 0xff,
0xf7, 0x7e, 0xaf, 0x7e, 0x0d, 0x1a, 0x95, 0x4c, 0x4f, 0xe7, 0x93, 0x38, 0x17, 0x3c, 0xc9, 0x45,
0xa5, 0x29, 0xab, 0x40, 0x16, 0x57, 0x8f, 0x0b, 0x56, 0x15, 0x62, 0xa1, 0x92, 0x69, 0xae, 0xd4,
0x94, 0x71, 0xbd, 0xac, 0x61, 0x53, 0xc4, 0xb5, 0x14, 0x5a, 0xe0, 0xde, 0x6f, 0x3c, 0x76, 0x78,
0xec, 0x88, 0xde, 0xbd, 0x52, 0x94, 0xc2, 0x60, 0x49, 0x7b, 0xb2, 0x1d, 0xbd, 0xb0, 0x14, 0xa2,
0x9c, 0x41, 0x62, 0xaa, 0xc9, 0xfc, 0x43, 0x52, 0xcc, 0x25, 0xd5, 0x4c, 0x54, 0x2e, 0x8f, 0xb6,
0x73, 0xcd, 0x38, 0x28, 0x4d, 0x79, 0x6d, 0x81, 0xc3, 0x1c, 0x75, 0x47, 0x12, 0xa8, 0x86, 0xd7,
0x75, 0xdb, 0xa6, 0x70, 0x86, 0xb0, 0x06, 0xc9, 0x59, 0x45, 0x35, 0x90, 0xb5, 0x2d, 0xf0, 0xfa,
0xde, 0xe0, 0xe6, 0xb3, 0xfb, 0xb1, 0xd5, 0xc5, 0x6b, 0x5d, 0x3c, 0x76, 0x40, 0xba, 0xbf, 0xba,
0x88, 0x3a, 0x5f, 0x7e, 0x44, 0x5e, 0x76, 0xb0, 0x69, 0x5f, 0x87, 0x87, 0x5f, 0x77, 0xd0, 0xad,
0x53, 0x29, 0x72, 0x50, 0x6a, 0x0c, 0x9a, 0xb2, 0x99, 0xc2, 0x8f, 0x10, 0x62, 0x9c, 0x96, 0x40,
0x2a, 0xca, 0xc1, 0xe8, 0xfd, 0xcc, 0x37, 0x37, 0x27, 0x94, 0x03, 0x1e, 0x21, 0x94, 0x9b, 0x9f,
0x55, 0x10, 0xaa, 0x83, 0x6b, 0x66, 0x7a, 0xef, 0xaf, 0xe9, 0x6f, 0xd6, 0x8f, 0xb1, 0xe3, 0x3f,
0xb7, 0xe3, 0x7d, 0xd7, 0xf7, 0x52, 0xe3, 0x27, 0x08, 0x9f, 0x83, 0xac, 0x60, 0x46, 0xda, 0x57,
0x93, 0xa3, 0xe1, 0x90, 0x54, 0x2a, 0xd8, 0xe9, 0x7b, 0x83, 0xdd, 0xec, 0xb6, 0x4d, 0x5a, 0xc3,
0xd1, 0x70, 0x78, 0xa2, 0x70, 0x8c, 0xee, 0x72, 0xe0, 0x42, 0x2e, 0x49, 0x2e, 0x38, 0x67, 0x9a,
0x4c, 0x96, 0x1a, 0x54, 0xb0, 0x6b, 0xe8, 0x03, 0x1b, 0x8d, 0x4c, 0x92, 0xb6, 0x01, 0x7e, 0x85,
0xfa, 0x8e, 0x5f, 0x08, 0x79, 0xce, 0xaa, 0x92, 0x28, 0xd0, 0xa4, 0x96, 0xec, 0x63, 0xbb, 0x38,
0xdb, 0x7c, 0xdd, 0x34, 0x3f, 0xb4, 0xdc, 0x5b, 0x8b, 0x9d, 0x81, 0x3e, 0xb5, 0x90, 0xf5, 0x8c,
0x51, 0xf4, 0x0f, 0x8f, 0x9a, 0x52, 0x09, 0x85, 0xd3, 0xec, 0x19, 0xcd, 0x83, 0x6d, 0xcd, 0x99,
0x61, 0xac, 0xe5, 0x29, 0x42, 0xb5, 0x5d, 0x30, 0x61, 0x45, 0x70, 0xa3, 0xef, 0x0d, 0xba, 0x69,
0xb7, 0xb9, 0x88, 0x7c, 0xb7, 0xf6, 0xe3, 0x71, 0xe6, 0x3b, 0xe0, 0xb8, 0xc0, 0x8f, 0xd1, 0x9d,
0xb9, 0x02, 0xf9, 0xc7, 0x5a, 0xf6, 0xcd, 0x90, 0x6e, 0x7b, 0xbf, 0x59, 0x4a, 0xfa, 0x7e, 0x75,
0x19, 0x76, 0xbe, 0x5f, 0x86, 0x9d, 0x4f, 0x4d, 0xe8, 0xad, 0x9a, 0xd0, 0xfb, 0xd6, 0x84, 0xde,
0xcf, 0x26, 0xf4, 0xde, 0xa5, 0xff, 0xf5, 0xbd, 0xbf, 0xb8, 0x5a, 0x4c, 0xf6, 0xcc, 0x1f, 0xf9,
0xfc, 0x57, 0x00, 0x00, 0x00, 0xff, 0xff, 0x22, 0xad, 0xdf, 0xf8, 0x3c, 0x03, 0x00, 0x00,
// 503 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x93, 0x41, 0x6f, 0xd3, 0x30,
0x14, 0xc7, 0x1b, 0x36, 0xba, 0xc5, 0xa8, 0xc0, 0x0c, 0x87, 0x52, 0x20, 0xa9, 0xc6, 0x81, 0x4a,
0xa0, 0xb4, 0x83, 0x23, 0x27, 0xd2, 0x82, 0xd4, 0xcb, 0x98, 0x32, 0x24, 0x24, 0x84, 0x64, 0xb9,
0xc9, 0x23, 0xb5, 0x56, 0xc7, 0x91, 0xed, 0xd2, 0xf5, 0xc6, 0x47, 0xe0, 0xc8, 0x47, 0xea, 0x91,
0x23, 0x12, 0x52, 0x61, 0xf9, 0x24, 0xc8, 0x76, 0xba, 0x8d, 0xc1, 0x89, 0x9b, 0xed, 0xff, 0xef,
0xfd, 0x5e, 0xfc, 0xac, 0xa0, 0x61, 0xce, 0xf4, 0x74, 0x3e, 0x89, 0x52, 0xc1, 0xfb, 0xa9, 0x28,
0x34, 0x65, 0x05, 0xc8, 0xec, 0xf2, 0x72, 0xc1, 0x8a, 0x4c, 0x2c, 0x54, 0x7f, 0x9a, 0x2a, 0x35,
0x65, 0x5c, 0x2f, 0x4b, 0x38, 0xdf, 0x44, 0xa5, 0x14, 0x5a, 0xe0, 0xce, 0x05, 0x1e, 0xd5, 0x78,
0x54, 0x13, 0x9d, 0xbb, 0xb9, 0xc8, 0x85, 0xc5, 0xfa, 0x66, 0xe5, 0x2a, 0x3a, 0x41, 0x2e, 0x44,
0x3e, 0x83, 0xbe, 0xdd, 0x4d, 0xe6, 0x1f, 0xfb, 0xd9, 0x5c, 0x52, 0xcd, 0x44, 0x51, 0xe7, 0xe1,
0xd5, 0x5c, 0x33, 0x0e, 0x4a, 0x53, 0x5e, 0x3a, 0x60, 0x3f, 0x45, 0xad, 0xa1, 0x04, 0xaa, 0xe1,
0x4d, 0x69, 0xca, 0x14, 0x4e, 0x10, 0xd6, 0x20, 0x39, 0x2b, 0xa8, 0x06, 0xb2, 0xb1, 0xb5, 0xbd,
0xae, 0xd7, 0xbb, 0xf1, 0xec, 0x5e, 0xe4, 0x74, 0xd1, 0x46, 0x17, 0x8d, 0x6a, 0x20, 0xde, 0x5d,
0xad, 0xc3, 0xc6, 0xd7, 0x9f, 0xa1, 0x97, 0xec, 0x9d, 0x97, 0x6f, 0xc2, 0xfd, 0x1f, 0x5b, 0xe8,
0xe6, 0x91, 0x14, 0x29, 0x28, 0x35, 0x02, 0x4d, 0xd9, 0x4c, 0xe1, 0x87, 0x08, 0x31, 0x4e, 0x73,
0x20, 0x05, 0xe5, 0x60, 0xf5, 0x7e, 0xe2, 0xdb, 0x93, 0x43, 0xca, 0x01, 0x0f, 0x11, 0x4a, 0xed,
0x67, 0x65, 0x84, 0xea, 0xf6, 0x35, 0xdb, 0xbd, 0xf3, 0x57, 0xf7, 0xb7, 0x9b, 0xcb, 0xb8, 0xf6,
0x5f, 0x4c, 0x7b, 0xbf, 0xae, 0x7b, 0xa9, 0xf1, 0x13, 0x84, 0x4f, 0x40, 0x16, 0x30, 0x23, 0xe6,
0xd6, 0xe4, 0x60, 0x30, 0x20, 0x85, 0x6a, 0x6f, 0x75, 0xbd, 0xde, 0x76, 0x72, 0xcb, 0x25, 0xc6,
0x70, 0x30, 0x18, 0x1c, 0x2a, 0x1c, 0xa1, 0x3b, 0x1c, 0xb8, 0x90, 0x4b, 0x92, 0x0a, 0xce, 0x99,
0x26, 0x93, 0xa5, 0x06, 0xd5, 0xde, 0xb6, 0xf4, 0x9e, 0x8b, 0x86, 0x36, 0x89, 0x4d, 0x80, 0x5f,
0xa3, 0x6e, 0xcd, 0x2f, 0x84, 0x3c, 0x61, 0x45, 0x4e, 0x14, 0x68, 0x52, 0x4a, 0xf6, 0xc9, 0x0c,
0xce, 0x15, 0x5f, 0xb7, 0xc5, 0x0f, 0x1c, 0xf7, 0xce, 0x61, 0xc7, 0xa0, 0x8f, 0x1c, 0xe4, 0x3c,
0x23, 0x14, 0xfe, 0xc3, 0xa3, 0xa6, 0x54, 0x42, 0x56, 0x6b, 0x9a, 0x56, 0x73, 0xff, 0xaa, 0xe6,
0xd8, 0x32, 0xce, 0xf2, 0x14, 0xa1, 0xd2, 0x0d, 0x98, 0xb0, 0xac, 0xbd, 0xd3, 0xf5, 0x7a, 0xad,
0xb8, 0x55, 0xad, 0x43, 0xbf, 0x1e, 0xfb, 0x78, 0x94, 0xf8, 0x35, 0x30, 0xce, 0xf0, 0x63, 0x74,
0x7b, 0xae, 0x40, 0xfe, 0x31, 0x96, 0x5d, 0xdb, 0xa4, 0x65, 0xce, 0x2f, 0x86, 0xf2, 0x08, 0xed,
0xc0, 0x29, 0xa4, 0xc6, 0xe9, 0x9b, 0x27, 0x8a, 0x51, 0xb5, 0x0e, 0x9b, 0xaf, 0x4e, 0x21, 0x1d,
0x8f, 0x92, 0xa6, 0x89, 0xc6, 0x59, 0xfc, 0x61, 0x75, 0x16, 0x34, 0xbe, 0x9f, 0x05, 0x8d, 0xcf,
0x55, 0xe0, 0xad, 0xaa, 0xc0, 0xfb, 0x56, 0x05, 0xde, 0xaf, 0x2a, 0xf0, 0xde, 0xc7, 0xff, 0xf5,
0x53, 0xbc, 0xb8, 0xbc, 0x99, 0x34, 0xed, 0x6b, 0x3f, 0xff, 0x1d, 0x00, 0x00, 0xff, 0xff, 0xff,
0xc7, 0x40, 0x0e, 0x61, 0x03, 0x00, 0x00,
}

1
windows/hcsshimtypes/hcsshim.proto
View File

@ -23,4 +23,5 @@ message ProcessDetails {
uint64 memory_working_set_shared_bytes = 6;
uint32 process_id = 7;
uint64 user_time_100_ns = 8;
string exec_id = 9;
}

7
windows/hcsshimtypes/next.pb.txt
View File

@ -144,6 +144,13 @@ file {
type: TYPE_UINT64
json_name: "userTime100Ns"
}
field {
name: "exec_id"
number: 9
label: LABEL_OPTIONAL
type: TYPE_STRING
json_name: "execId"
}
}
options {
go_package: "github.com/containerd/containerd/windows/hcsshimtypes;hcsshimtypes"

4
windows/process.go
View File

@ -99,6 +99,10 @@ func (p *process) Pid() uint32 {
return p.pid
}
func (p *process) HcsPid() uint32 {
return uint32(p.hcs.Pid())
}
func (p *process) ExitCode() (uint32, time.Time, error) {
if s := p.Status(); s != runtime.StoppedStatus && s != runtime.CreatedStatus {
return 255, time.Time{}, errors.Wrapf(errdefs.ErrFailedPrecondition, "process is not stopped: %s", s)

42
windows/task.go
View File

@ -218,24 +218,36 @@ func (t *task) Pids(ctx context.Context) ([]runtime.ProcessInfo, error) {
t.Lock()
defer t.Unlock()
var infoList []runtime.ProcessInfo
var processList []runtime.ProcessInfo
hcsProcessList, err := t.hcsContainer.ProcessList()
if err != nil {
return nil, err
}
for _, process := range hcsProcessList {
info, err := t.convertToProcessDetails(process)
if err != nil {
return nil, err
for _, hcsProcess := range hcsProcessList {
info := &hcsshimtypes.ProcessDetails{
ImageName: hcsProcess.ImageName,
CreatedAt: hcsProcess.CreateTimestamp,
KernelTime_100Ns: hcsProcess.KernelTime100ns,
MemoryCommitBytes: hcsProcess.MemoryCommitBytes,
MemoryWorkingSetPrivateBytes: hcsProcess.MemoryWorkingSetPrivateBytes,
MemoryWorkingSetSharedBytes: hcsProcess.MemoryWorkingSetSharedBytes,
ProcessID: hcsProcess.ProcessId,
UserTime_100Ns: hcsProcess.UserTime100ns,
}
infoList = append(infoList, runtime.ProcessInfo{
Pid: process.ProcessId,
for _, p := range t.processes {
if p.HcsPid() == hcsProcess.ProcessId {
info.ExecID = p.ID()
break
}
}
processList = append(processList, runtime.ProcessInfo{
Pid: hcsProcess.ProcessId,
Info: info,
})
}
return infoList, nil
return processList, nil
}
func (t *task) Checkpoint(_ context.Context, _ string, _ *types.Any) error {
@ -397,17 +409,3 @@ func (t *task) cleanup() {
removeLayer(context.Background(), t.rwLayer)
t.Unlock()
}
// convertToProcessDetails converts a given hcsshim ProcessListItem to proto ProcessDetails
func (t *task) convertToProcessDetails(p hcsshim.ProcessListItem) (*hcsshimtypes.ProcessDetails, error) {
return &hcsshimtypes.ProcessDetails{
ImageName: p.ImageName,
CreatedAt: p.CreateTimestamp,
KernelTime_100Ns: p.KernelTime100ns,
MemoryCommitBytes: p.MemoryCommitBytes,
MemoryWorkingSetPrivateBytes: p.MemoryWorkingSetPrivateBytes,
MemoryWorkingSetSharedBytes: p.MemoryWorkingSetSharedBytes,
ProcessID: p.ProcessId,
UserTime_100Ns: p.UserTime100ns,
}, nil
}