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

Refactor task service metrics

Browse Source 
Signed-off-by: Michael Crosby <crosbymichael@gmail.com>
This commit is contained in:
Michael Crosby 2017-09-05 11:50:56 -04:00
parent 16fcb8dc08
commit 697dcdd407
12 changed files with 965 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
api/next.pb.txt
View File

@ -2884,10 +2884,66 @@ file {
}
syntax: "proto3"
}
file {
name: "github.com/containerd/containerd/api/types/metrics.proto"
package: "containerd.types"
dependency: "gogoproto/gogo.proto"
dependency: "google/protobuf/any.proto"
dependency: "google/protobuf/timestamp.proto"
message_type {
name: "MetricsRequest"
field {
name: "filters"
number: 1
label: LABEL_REPEATED
type: TYPE_STRING
json_name: "filters"
}
}
message_type {
name: "MetricsResponse"
field {
name: "metrics"
number: 1
label: LABEL_REPEATED
type: TYPE_MESSAGE
type_name: ".containerd.types.Metric"
json_name: "metrics"
}
}
message_type {
name: "Metric"
field {
name: "timestamp"
number: 1
label: LABEL_OPTIONAL
type: TYPE_MESSAGE
type_name: ".google.protobuf.Timestamp"
options {
65010: 1
65001: 0
}
json_name: "timestamp"
}
field {
name: "data"
number: 2
label: LABEL_OPTIONAL
type: TYPE_MESSAGE
type_name: ".google.protobuf.Any"
json_name: "data"
}
}
options {
go_package: "github.com/containerd/containerd/api/types;types"
}
syntax: "proto3"
}
file {
name: "github.com/containerd/containerd/api/types/task/task.proto"
package: "containerd.v1.types"
dependency: "gogoproto/gogo.proto"
dependency: "google/protobuf/timestamp.proto"
message_type {
name: "Process"
field {
@ -2954,6 +3010,18 @@ file {
type: TYPE_UINT32
json_name: "exitStatus"
}
field {
name: "exited_at"
number: 10
label: LABEL_OPTIONAL
type: TYPE_MESSAGE
type_name: ".google.protobuf.Timestamp"
options {
65010: 1
65001: 0
}
json_name: "exitedAt"
}
}
enum_type {
name: "Status"
@ -3013,6 +3081,7 @@ file {
dependency: "google/protobuf/any.proto"
dependency: "gogoproto/gogo.proto"
dependency: "github.com/containerd/containerd/api/types/mount.proto"
dependency: "github.com/containerd/containerd/api/types/metrics.proto"
dependency: "github.com/containerd/containerd/api/types/descriptor.proto"
dependency: "github.com/containerd/containerd/api/types/task/task.proto"
dependency: "google/protobuf/timestamp.proto"
@ -3551,6 +3620,11 @@ file {
input_type: ".containerd.services.tasks.v1.UpdateTaskRequest"
output_type: ".google.protobuf.Empty"
}
method {
name: "Metrics"
input_type: ".containerd.types.MetricsRequest"
output_type: ".containerd.types.MetricsResponse"
}
}
options {
go_package: "github.com/containerd/containerd/api/services/tasks/v1;tasks"

202
api/services/tasks/v1/tasks.pb.go
View File

@ -43,6 +43,7 @@ import google_protobuf1 "github.com/gogo/protobuf/types"
import _ "github.com/gogo/protobuf/gogoproto"
import containerd_types "github.com/containerd/containerd/api/types"
import containerd_types1 "github.com/containerd/containerd/api/types"
import containerd_types2 "github.com/containerd/containerd/api/types"
import containerd_v1_types "github.com/containerd/containerd/api/types/task"
import _ "github.com/gogo/protobuf/types"
@ -86,7 +87,7 @@ type CreateTaskRequest struct {
Stdout string `protobuf:"bytes,5,opt,name=stdout,proto3" json:"stdout,omitempty"`
Stderr string `protobuf:"bytes,6,opt,name=stderr,proto3" json:"stderr,omitempty"`
Terminal bool `protobuf:"varint,7,opt,name=terminal,proto3" json:"terminal,omitempty"`
Checkpoint *containerd_types1.Descriptor `protobuf:"bytes,8,opt,name=checkpoint" json:"checkpoint,omitempty"`
Checkpoint *containerd_types2.Descriptor `protobuf:"bytes,8,opt,name=checkpoint" json:"checkpoint,omitempty"`
Options *google_protobuf1.Any `protobuf:"bytes,9,opt,name=options" json:"options,omitempty"`
}
@ -281,7 +282,7 @@ func (*CheckpointTaskRequest) ProtoMessage() {}
func (*CheckpointTaskRequest) Descriptor() ([]byte, []int) { return fileDescriptorTasks, []int{20} }
type CheckpointTaskResponse struct {
Descriptors []*containerd_types1.Descriptor `protobuf:"bytes,1,rep,name=descriptors" json:"descriptors,omitempty"`
Descriptors []*containerd_types2.Descriptor `protobuf:"bytes,1,rep,name=descriptors" json:"descriptors,omitempty"`
}
func (m *CheckpointTaskResponse) Reset() { *m = CheckpointTaskResponse{} }
@ -353,6 +354,7 @@ type TasksClient interface {
ListPids(ctx context.Context, in *ListPidsRequest, opts ...grpc.CallOption) (*ListPidsResponse, error)
Checkpoint(ctx context.Context, in *CheckpointTaskRequest, opts ...grpc.CallOption) (*CheckpointTaskResponse, error)
Update(ctx context.Context, in *UpdateTaskRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
Metrics(ctx context.Context, in *containerd_types1.MetricsRequest, opts ...grpc.CallOption) (*containerd_types1.MetricsResponse, error)
}
type tasksClient struct {
@ -498,6 +500,15 @@ func (c *tasksClient) Update(ctx context.Context, in *UpdateTaskRequest, opts ..
return out, nil
}
func (c *tasksClient) Metrics(ctx context.Context, in *containerd_types1.MetricsRequest, opts ...grpc.CallOption) (*containerd_types1.MetricsResponse, error) {
out := new(containerd_types1.MetricsResponse)
err := grpc.Invoke(ctx, "/containerd.services.tasks.v1.Tasks/Metrics", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for Tasks service
type TasksServer interface {
@ -520,6 +531,7 @@ type TasksServer interface {
ListPids(context.Context, *ListPidsRequest) (*ListPidsResponse, error)
Checkpoint(context.Context, *CheckpointTaskRequest) (*CheckpointTaskResponse, error)
Update(context.Context, *UpdateTaskRequest) (*google_protobuf.Empty, error)
Metrics(context.Context, *containerd_types1.MetricsRequest) (*containerd_types1.MetricsResponse, error)
}
func RegisterTasksServer(s *grpc.Server, srv TasksServer) {
@ -796,6 +808,24 @@ func _Tasks_Update_Handler(srv interface{}, ctx context.Context, dec func(interf
return interceptor(ctx, in, info, handler)
}
func _Tasks_Metrics_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(containerd_types1.MetricsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(TasksServer).Metrics(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/containerd.services.tasks.v1.Tasks/Metrics",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(TasksServer).Metrics(ctx, req.(*containerd_types1.MetricsRequest))
}
return interceptor(ctx, in, info, handler)
}
var _Tasks_serviceDesc = grpc.ServiceDesc{
ServiceName: "containerd.services.tasks.v1.Tasks",
HandlerType: (*TasksServer)(nil),
@ -860,6 +890,10 @@ var _Tasks_serviceDesc = grpc.ServiceDesc{
MethodName: "Update",
Handler: _Tasks_Update_Handler,
},
{
MethodName: "Metrics",
Handler: _Tasks_Metrics_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "github.com/containerd/containerd/api/services/tasks/v1/tasks.proto",
@ -2058,7 +2092,7 @@ func (this *CreateTaskRequest) String() string {
`Stdout:` + fmt.Sprintf("%v", this.Stdout) + `,`,
`Stderr:` + fmt.Sprintf("%v", this.Stderr) + `,`,
`Terminal:` + fmt.Sprintf("%v", this.Terminal) + `,`,
`Checkpoint:` + strings.Replace(fmt.Sprintf("%v", this.Checkpoint), "Descriptor", "containerd_types1.Descriptor", 1) + `,`,
`Checkpoint:` + strings.Replace(fmt.Sprintf("%v", this.Checkpoint), "Descriptor", "containerd_types2.Descriptor", 1) + `,`,
`Options:` + strings.Replace(fmt.Sprintf("%v", this.Options), "Any", "google_protobuf1.Any", 1) + `,`,
`}`,
}, "")
@ -2291,7 +2325,7 @@ func (this *CheckpointTaskResponse) String() string {
return "nil"
}
s := strings.Join([]string{`&CheckpointTaskResponse{`,
`Descriptors:` + strings.Replace(fmt.Sprintf("%v", this.Descriptors), "Descriptor", "containerd_types1.Descriptor", 1) + `,`,
`Descriptors:` + strings.Replace(fmt.Sprintf("%v", this.Descriptors), "Descriptor", "containerd_types2.Descriptor", 1) + `,`,
`}`,
}, "")
return s
@ -2538,7 +2572,7 @@ func (m *CreateTaskRequest) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.Checkpoint == nil {
m.Checkpoint = &containerd_types1.Descriptor{}
m.Checkpoint = &containerd_types2.Descriptor{}
}
if err := m.Checkpoint.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -4822,7 +4856,7 @@ func (m *CheckpointTaskResponse) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Descriptors = append(m.Descriptors, &containerd_types1.Descriptor{})
m.Descriptors = append(m.Descriptors, &containerd_types2.Descriptor{})
if err := m.Descriptors[len(m.Descriptors)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
@ -5070,81 +5104,83 @@ func init() {
}
var fileDescriptorTasks = []byte{
// 1207 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0xcd, 0x6f, 0x1b, 0x45,
0x14, 0xef, 0xfa, 0x63, 0x6d, 0x3f, 0x37, 0x6d, 0x32, 0xa4, 0xc1, 0x2c, 0x95, 0x1d, 0x16, 0x09,
0x99, 0x42, 0x77, 0xa9, 0x8b, 0x7a, 0xa0, 0x15, 0x52, 0x13, 0x87, 0xc8, 0x02, 0xd4, 0x74, 0x53,
0x10, 0xca, 0xc5, 0x6c, 0xbc, 0x13, 0x67, 0x14, 0x7b, 0x77, 0xbb, 0x33, 0x4e, 0x13, 0x38, 0xc0,
0x9f, 0xd0, 0x0b, 0x07, 0x2e, 0xfc, 0x3d, 0x39, 0x72, 0x44, 0x08, 0x05, 0xea, 0xff, 0x82, 0x1b,
0x9a, 0x0f, 0x6f, 0x36, 0x76, 0xfc, 0x91, 0xba, 0xe1, 0x92, 0xcc, 0xcc, 0xbe, 0xaf, 0xf9, 0xbd,
0x37, 0xbf, 0xf7, 0x12, 0x58, 0x6b, 0x13, 0xb6, 0xdf, 0xdb, 0xb5, 0x5a, 0x41, 0xd7, 0x6e, 0x05,
0x3e, 0x73, 0x89, 0x8f, 0x23, 0x2f, 0xb9, 0x74, 0x43, 0x62, 0x53, 0x1c, 0x1d, 0x92, 0x16, 0xa6,
0x36, 0x73, 0xe9, 0x01, 0xb5, 0x0f, 0xef, 0xc9, 0x85, 0x15, 0x46, 0x01, 0x0b, 0xd0, 0xed, 0x33,
0x69, 0x6b, 0x20, 0x69, 0x49, 0x81, 0xc3, 0x7b, 0xc6, 0xbb, 0xed, 0x20, 0x68, 0x77, 0xb0, 0x2d,
0x64, 0x77, 0x7b, 0x7b, 0x36, 0xee, 0x86, 0xec, 0x58, 0xaa, 0x1a, 0xef, 0x0c, 0x7f, 0x74, 0xfd,
0xc1, 0xa7, 0xe5, 0x76, 0xd0, 0x0e, 0xc4, 0xd2, 0xe6, 0x2b, 0x75, 0xfa, 0x60, 0xa6, 0x78, 0xd9,
0x71, 0x88, 0xa9, 0xdd, 0x0d, 0x7a, 0x3e, 0x53, 0x7a, 0x0f, 0x2f, 0xa1, 0xe7, 0x61, 0xda, 0x8a,
0x48, 0xc8, 0x82, 0x48, 0x29, 0x7f, 0x76, 0x09, 0x65, 0x7e, 0x6f, 0xf1, 0x43, 0xe9, 0x56, 0x86,
0x6f, 0xc8, 0x48, 0x17, 0x53, 0xe6, 0x76, 0x43, 0x29, 0x60, 0x9e, 0xa4, 0x60, 0x69, 0x3d, 0xc2,
0x2e, 0xc3, 0xcf, 0x5c, 0x7a, 0xe0, 0xe0, 0xe7, 0x3d, 0x4c, 0x19, 0xaa, 0xc1, 0xf5, 0xd8, 0x7c,
0x93, 0x78, 0x25, 0x6d, 0x55, 0xab, 0x16, 0xd6, 0x6e, 0xf6, 0x4f, 0x2b, 0xc5, 0xf5, 0xc1, 0x79,
0xa3, 0xee, 0x14, 0x63, 0xa1, 0x86, 0x87, 0x6c, 0xd0, 0xa3, 0x20, 0x60, 0x7b, 0xb4, 0x94, 0x5e,
0x4d, 0x57, 0x8b, 0xb5, 0xb7, 0xad, 0x44, 0x62, 0x44, 0x74, 0xd6, 0xd7, 0x1c, 0x12, 0x47, 0x89,
0xa1, 0x65, 0xc8, 0x52, 0xe6, 0x11, 0xbf, 0x94, 0xe1, 0xd6, 0x1d, 0xb9, 0x41, 0x2b, 0xa0, 0x53,
0xe6, 0x05, 0x3d, 0x56, 0xca, 0x8a, 0x63, 0xb5, 0x53, 0xe7, 0x38, 0x8a, 0x4a, 0x7a, 0x7c, 0x8e,
0xa3, 0x08, 0x19, 0x90, 0x67, 0x38, 0xea, 0x12, 0xdf, 0xed, 0x94, 0x72, 0xab, 0x5a, 0x35, 0xef,
0xc4, 0x7b, 0xf4, 0x08, 0xa0, 0xb5, 0x8f, 0x5b, 0x07, 0x61, 0x40, 0x7c, 0x56, 0xca, 0xaf, 0x6a,
0xd5, 0x62, 0xed, 0xf6, 0x68, 0x58, 0xf5, 0x18, 0x71, 0x27, 0x21, 0x8f, 0x2c, 0xc8, 0x05, 0x21,
0x23, 0x81, 0x4f, 0x4b, 0x05, 0xa1, 0xba, 0x6c, 0x49, 0x34, 0xad, 0x01, 0x9a, 0xd6, 0x63, 0xff,
0xd8, 0x19, 0x08, 0x99, 0x3b, 0x80, 0x92, 0x48, 0xd2, 0x30, 0xf0, 0x29, 0x7e, 0x2d, 0x28, 0x17,
0x21, 0x1d, 0x12, 0xaf, 0x94, 0x5a, 0xd5, 0xaa, 0x0b, 0x0e, 0x5f, 0x9a, 0x6d, 0xb8, 0xbe, 0xcd,
0xdc, 0x88, 0xcd, 0x93, 0xa0, 0xf7, 0x21, 0x87, 0x8f, 0x70, 0xab, 0xa9, 0x2c, 0x17, 0xd6, 0xa0,
0x7f, 0x5a, 0xd1, 0x37, 0x8e, 0x70, 0xab, 0x51, 0x77, 0x74, 0xfe, 0xa9, 0xe1, 0x99, 0xef, 0xc1,
0x82, 0x72, 0xa4, 0xe2, 0x57, 0xb1, 0x68, 0x67, 0xb1, 0x6c, 0xc2, 0x52, 0x1d, 0x77, 0xf0, 0xdc,
0x15, 0x63, 0xfe, 0xa6, 0xc1, 0x0d, 0x69, 0x29, 0xf6, 0xb6, 0x02, 0xa9, 0x58, 0x59, 0xef, 0x9f,
0x56, 0x52, 0x8d, 0xba, 0x93, 0x22, 0x17, 0x20, 0x82, 0x2a, 0x50, 0xc4, 0x47, 0x84, 0x35, 0x29,
0x73, 0x59, 0x8f, 0xd7, 0x1c, 0xff, 0x02, 0xfc, 0x68, 0x5b, 0x9c, 0xa0, 0xc7, 0x50, 0xe0, 0x3b,
0xec, 0x35, 0x5d, 0x26, 0x4a, 0xac, 0x58, 0x33, 0x46, 0x12, 0xf8, 0x6c, 0xf0, 0x1c, 0xd6, 0xf2,
0x27, 0xa7, 0x95, 0x6b, 0x2f, 0xff, 0xae, 0x68, 0x4e, 0x5e, 0xaa, 0x3d, 0x66, 0x66, 0x00, 0xcb,
0x32, 0xbe, 0xad, 0x28, 0x68, 0x61, 0x4a, 0xaf, 0x1c, 0x7d, 0x0c, 0xb0, 0x89, 0xaf, 0x3e, 0xc9,
0x1b, 0x50, 0x14, 0x6e, 0x14, 0xe8, 0x0f, 0x20, 0x17, 0xca, 0x0b, 0x0a, 0x17, 0x43, 0x6f, 0xe4,
0xf0, 0x9e, 0x7a, 0x26, 0x03, 0x10, 0x06, 0xc2, 0xe6, 0x1d, 0x58, 0xfc, 0x8a, 0x50, 0xc6, 0xcb,
0x20, 0x86, 0x66, 0x05, 0xf4, 0x3d, 0xd2, 0x61, 0x38, 0x92, 0xd1, 0x3a, 0x6a, 0xc7, 0x8b, 0x26,
0x21, 0x1b, 0xbf, 0x8d, 0xac, 0x20, 0xea, 0x92, 0x26, 0x18, 0x63, 0xb2, 0x5b, 0x29, 0x6a, 0xbe,
0xd4, 0xa0, 0xf8, 0x25, 0xe9, 0x74, 0xae, 0x1a, 0x24, 0x41, 0x38, 0xa4, 0xcd, 0x69, 0x45, 0xd6,
0x96, 0xda, 0xf1, 0x52, 0x74, 0x3b, 0x1d, 0x51, 0x51, 0x79, 0x87, 0x2f, 0xcd, 0x7f, 0x35, 0x40,
0x5c, 0xf9, 0x0d, 0x54, 0x49, 0xcc, 0x89, 0xa9, 0x8b, 0x39, 0x31, 0x3d, 0x86, 0x13, 0x33, 0x63,
0x39, 0x31, 0x3b, 0xc4, 0x89, 0x55, 0xc8, 0xd0, 0x10, 0xb7, 0x04, 0x8b, 0x8e, 0xa3, 0x34, 0x21,
0x91, 0x44, 0x29, 0x37, 0xb6, 0x94, 0x6e, 0xc1, 0x5b, 0xe7, 0xae, 0x2e, 0x33, 0x6b, 0xfe, 0xaa,
0xc1, 0xa2, 0x83, 0x29, 0xf9, 0x01, 0x6f, 0xb1, 0xe3, 0x2b, 0x4f, 0xd5, 0x32, 0x64, 0x5f, 0x10,
0x8f, 0xed, 0xab, 0x4c, 0xc9, 0x0d, 0x47, 0x67, 0x1f, 0x93, 0xf6, 0xbe, 0x7c, 0xfd, 0x0b, 0x8e,
0xda, 0x99, 0x3f, 0xc1, 0x8d, 0xf5, 0x4e, 0x40, 0x71, 0xe3, 0xc9, 0xff, 0x11, 0x98, 0x4c, 0x67,
0x5a, 0x64, 0x41, 0x6e, 0xcc, 0x2f, 0x60, 0x71, 0xcb, 0xed, 0xd1, 0xb9, 0xf9, 0x73, 0x13, 0x96,
0x1c, 0x4c, 0x7b, 0xdd, 0xb9, 0x0d, 0x6d, 0xc0, 0x4d, 0xfe, 0x38, 0xb7, 0x88, 0x37, 0x4f, 0xf1,
0x9a, 0x1f, 0x48, 0x3e, 0x90, 0x66, 0xd4, 0x13, 0x47, 0x90, 0x09, 0x89, 0x27, 0x5f, 0xf8, 0x82,
0x23, 0xd6, 0xe6, 0x5f, 0x1a, 0xdc, 0x5a, 0x8f, 0xfb, 0xec, 0xbc, 0x73, 0x47, 0x13, 0x96, 0x42,
0x37, 0xc2, 0x3e, 0x6b, 0x26, 0x7a, 0xbd, 0x4c, 0x49, 0x8d, 0x73, 0xfa, 0x9f, 0xa7, 0x95, 0x3b,
0x89, 0x09, 0x2a, 0x08, 0xb1, 0x1f, 0xab, 0x53, 0xbb, 0x1d, 0xdc, 0xf5, 0x48, 0x1b, 0x53, 0x66,
0xd5, 0xc5, 0x2f, 0x67, 0x51, 0x1a, 0x5b, 0xbf, 0x70, 0x0e, 0x48, 0xcf, 0x32, 0x07, 0x7c, 0x07,
0x2b, 0xc3, 0xb7, 0x53, 0x60, 0x7c, 0x0e, 0xc5, 0xb3, 0xe9, 0xee, 0x42, 0xd6, 0x1b, 0x19, 0x48,
0x92, 0x0a, 0xe6, 0x8f, 0xb0, 0xf4, 0x4d, 0xe8, 0xbd, 0x81, 0x59, 0xad, 0x06, 0x85, 0x08, 0xd3,
0xa0, 0x17, 0xb5, 0x30, 0x15, 0x58, 0x8d, 0xbb, 0xd4, 0x99, 0x58, 0xed, 0x97, 0x22, 0x64, 0x05,
0x7d, 0xa3, 0x03, 0xd0, 0xe5, 0xa0, 0x83, 0x6c, 0x6b, 0xd2, 0xf0, 0x6d, 0x8d, 0x0c, 0x96, 0xc6,
0x27, 0xb3, 0x2b, 0x28, 0xcc, 0xbe, 0x87, 0xac, 0x18, 0x48, 0xd0, 0x9d, 0xc9, 0xaa, 0xc9, 0xf1,
0xc8, 0xf8, 0x68, 0x26, 0x59, 0xe5, 0xa1, 0x0d, 0xba, 0xec, 0xf2, 0xd3, 0xae, 0x33, 0x32, 0xf5,
0x18, 0x1f, 0xcf, 0xa2, 0x10, 0x3b, 0x7a, 0x0e, 0x0b, 0xe7, 0xc6, 0x09, 0x54, 0x9b, 0x45, 0xfd,
0x7c, 0x57, 0xb9, 0xa4, 0xcb, 0x1d, 0x48, 0x6f, 0x62, 0x86, 0xaa, 0x93, 0x95, 0xce, 0x66, 0x0e,
0xe3, 0xc3, 0x19, 0x24, 0x63, 0xdc, 0x32, 0xfc, 0xb9, 0x23, 0x6b, 0xb2, 0xca, 0xf0, 0x88, 0x60,
0xd8, 0x33, 0xcb, 0x2b, 0x47, 0x0d, 0xc8, 0xf0, 0x8e, 0x8f, 0xa6, 0xc4, 0x96, 0x98, 0x0a, 0x8c,
0x95, 0x91, 0x6a, 0xde, 0xe0, 0x7f, 0xf7, 0xa1, 0x2d, 0xc8, 0x70, 0x8a, 0x46, 0x53, 0xea, 0x70,
0xb4, 0x9b, 0x8f, 0xb5, 0xb8, 0x0d, 0x85, 0xb8, 0xd1, 0x4d, 0x83, 0x62, 0xb8, 0x23, 0x8e, 0x35,
0xfa, 0x04, 0x72, 0xaa, 0x45, 0xa1, 0x29, 0xf9, 0x3e, 0xdf, 0xc9, 0x26, 0x18, 0xcc, 0x8a, 0x96,
0x33, 0x2d, 0xc2, 0xe1, 0xbe, 0x34, 0xd6, 0xe0, 0x53, 0xd0, 0x65, 0xef, 0x99, 0xf6, 0x68, 0x46,
0x3a, 0xd4, 0x58, 0x93, 0x04, 0xf2, 0x83, 0xf6, 0x81, 0xee, 0x4e, 0xaf, 0x91, 0x44, 0xb7, 0x32,
0xac, 0x59, 0xc5, 0x55, 0x45, 0xbd, 0x00, 0x48, 0x10, 0xfc, 0xfd, 0x29, 0x10, 0x5f, 0xd4, 0xaa,
0x8c, 0x4f, 0x2f, 0xa7, 0xa4, 0x1c, 0x3f, 0x05, 0x5d, 0x32, 0xf8, 0x34, 0xd8, 0x46, 0x78, 0x7e,
0x1c, 0x6c, 0x6b, 0xdf, 0x9e, 0xbc, 0x2a, 0x5f, 0xfb, 0xe3, 0x55, 0xf9, 0xda, 0xcf, 0xfd, 0xb2,
0x76, 0xd2, 0x2f, 0x6b, 0xbf, 0xf7, 0xcb, 0xda, 0x3f, 0xfd, 0xb2, 0xb6, 0xf3, 0xe8, 0xf5, 0xfe,
0xbb, 0xf2, 0x50, 0x2c, 0x76, 0x75, 0xe1, 0xe7, 0xfe, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x17,
0xec, 0xf8, 0x44, 0xa4, 0x11, 0x00, 0x00,
// 1238 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0x5f, 0x6f, 0x1b, 0x45,
0x10, 0xef, 0xf9, 0xcf, 0xd9, 0x1e, 0x37, 0x6d, 0xb2, 0xa4, 0xc1, 0x1c, 0x95, 0xed, 0x1e, 0x12,
0x32, 0x85, 0xde, 0x51, 0x17, 0x55, 0x88, 0x56, 0x48, 0x4d, 0x1c, 0x22, 0x0b, 0x4a, 0xd3, 0x6b,
0x41, 0xa8, 0x2f, 0xe6, 0x72, 0xb7, 0x71, 0x56, 0xb1, 0xef, 0xae, 0xb7, 0xeb, 0x34, 0x81, 0x07,
0xf8, 0x08, 0x7d, 0xe5, 0x85, 0xcf, 0x93, 0x47, 0x1e, 0x11, 0x42, 0x81, 0x5a, 0xe2, 0x43, 0xf0,
0x86, 0x6e, 0x77, 0x7d, 0xb9, 0xf8, 0x7f, 0xea, 0x86, 0x97, 0x64, 0xff, 0xcc, 0xcc, 0xce, 0xfe,
0x66, 0xf6, 0x37, 0xe3, 0x83, 0xf5, 0x36, 0x61, 0x7b, 0xbd, 0x1d, 0xc3, 0xf1, 0xbb, 0xa6, 0xe3,
0x7b, 0xcc, 0x26, 0x1e, 0x0e, 0xdd, 0xe4, 0xd0, 0x0e, 0x88, 0x49, 0x71, 0x78, 0x40, 0x1c, 0x4c,
0x4d, 0x66, 0xd3, 0x7d, 0x6a, 0x1e, 0xdc, 0x16, 0x03, 0x23, 0x08, 0x7d, 0xe6, 0xa3, 0xeb, 0xa7,
0xd2, 0xc6, 0x40, 0xd2, 0x10, 0x02, 0x07, 0xb7, 0xb5, 0x77, 0xdb, 0xbe, 0xdf, 0xee, 0x60, 0x93,
0xcb, 0xee, 0xf4, 0x76, 0x4d, 0xdc, 0x0d, 0xd8, 0x91, 0x50, 0xd5, 0xde, 0x19, 0xde, 0xb4, 0xbd,
0xc1, 0xd6, 0x6a, 0xdb, 0x6f, 0xfb, 0x7c, 0x68, 0x46, 0x23, 0xb9, 0x7a, 0x77, 0x2e, 0x7f, 0xd9,
0x51, 0x80, 0xa9, 0xd9, 0xf5, 0x7b, 0x1e, 0x93, 0x7a, 0x9f, 0x9e, 0x47, 0x0f, 0xb3, 0x90, 0x38,
0xf2, 0x76, 0xda, 0xbd, 0x73, 0x68, 0xba, 0x98, 0x3a, 0x21, 0x09, 0x98, 0x1f, 0x4a, 0xe5, 0xcf,
0xce, 0xa1, 0x1c, 0x21, 0xc6, 0xff, 0x48, 0xdd, 0xca, 0x30, 0x36, 0x8c, 0x74, 0x31, 0x65, 0x76,
0x37, 0x10, 0x02, 0xfa, 0x71, 0x0a, 0x56, 0x36, 0x42, 0x6c, 0x33, 0xfc, 0xd4, 0xa6, 0xfb, 0x16,
0x7e, 0xde, 0xc3, 0x94, 0xa1, 0x3a, 0x5c, 0x8e, 0xcd, 0xb7, 0x88, 0x5b, 0x52, 0xaa, 0x4a, 0xad,
0xb0, 0x7e, 0xb5, 0x7f, 0x52, 0x29, 0x6e, 0x0c, 0xd6, 0x9b, 0x0d, 0xab, 0x18, 0x0b, 0x35, 0x5d,
0x64, 0x82, 0x1a, 0xfa, 0x3e, 0xdb, 0xa5, 0xa5, 0x74, 0x35, 0x5d, 0x2b, 0xd6, 0xdf, 0x36, 0x12,
0x21, 0xe5, 0xde, 0x19, 0x0f, 0x23, 0x30, 0x2d, 0x29, 0x86, 0x56, 0x21, 0x4b, 0x99, 0x4b, 0xbc,
0x52, 0x26, 0xb2, 0x6e, 0x89, 0x09, 0x5a, 0x03, 0x95, 0x32, 0xd7, 0xef, 0xb1, 0x52, 0x96, 0x2f,
0xcb, 0x99, 0x5c, 0xc7, 0x61, 0x58, 0x52, 0xe3, 0x75, 0x1c, 0x86, 0x48, 0x83, 0x3c, 0xc3, 0x61,
0x97, 0x78, 0x76, 0xa7, 0x94, 0xab, 0x2a, 0xb5, 0xbc, 0x15, 0xcf, 0xd1, 0x7d, 0x00, 0x67, 0x0f,
0x3b, 0xfb, 0x81, 0x4f, 0x3c, 0x56, 0xca, 0x57, 0x95, 0x5a, 0xb1, 0x7e, 0x7d, 0xd4, 0xad, 0x46,
0x8c, 0xb8, 0x95, 0x90, 0x47, 0x06, 0xe4, 0xfc, 0x80, 0x11, 0xdf, 0xa3, 0xa5, 0x02, 0x57, 0x5d,
0x35, 0x04, 0x9a, 0xc6, 0x00, 0x4d, 0xe3, 0x81, 0x77, 0x64, 0x0d, 0x84, 0xf4, 0x67, 0x80, 0x92,
0x48, 0xd2, 0xc0, 0xf7, 0x28, 0x7e, 0x2d, 0x28, 0x97, 0x21, 0x1d, 0x10, 0xb7, 0x94, 0xaa, 0x2a,
0xb5, 0x25, 0x2b, 0x1a, 0xea, 0x6d, 0xb8, 0xfc, 0x84, 0xd9, 0x21, 0x5b, 0x24, 0x40, 0xef, 0x41,
0x0e, 0x1f, 0x62, 0xa7, 0x25, 0x2d, 0x17, 0xd6, 0xa1, 0x7f, 0x52, 0x51, 0x37, 0x0f, 0xb1, 0xd3,
0x6c, 0x58, 0x6a, 0xb4, 0xd5, 0x74, 0xf5, 0x1b, 0xb0, 0x24, 0x0f, 0x92, 0xfe, 0x4b, 0x5f, 0x94,
0x53, 0x5f, 0xb6, 0x60, 0xa5, 0x81, 0x3b, 0x78, 0xe1, 0x8c, 0xd1, 0x7f, 0x55, 0xe0, 0x8a, 0xb0,
0x14, 0x9f, 0xb6, 0x06, 0xa9, 0x58, 0x59, 0xed, 0x9f, 0x54, 0x52, 0xcd, 0x86, 0x95, 0x22, 0x63,
0x10, 0x41, 0x15, 0x28, 0xe2, 0x43, 0xc2, 0x5a, 0x94, 0xd9, 0xac, 0x17, 0xe5, 0x5c, 0xb4, 0x03,
0xd1, 0xd2, 0x13, 0xbe, 0x82, 0x1e, 0x40, 0x21, 0x9a, 0x61, 0xb7, 0x65, 0x33, 0x9e, 0x62, 0xc5,
0xba, 0x36, 0x12, 0xc0, 0xa7, 0x83, 0xe7, 0xb0, 0x9e, 0x3f, 0x3e, 0xa9, 0x5c, 0x7a, 0xf9, 0x57,
0x45, 0xb1, 0xf2, 0x42, 0xed, 0x01, 0xd3, 0x7d, 0x58, 0x15, 0xfe, 0x6d, 0x87, 0xbe, 0x83, 0x29,
0xbd, 0x70, 0xf4, 0x31, 0xc0, 0x16, 0xbe, 0xf8, 0x20, 0x6f, 0x42, 0x91, 0x1f, 0x23, 0x41, 0xbf,
0x0b, 0xb9, 0x40, 0x5c, 0x90, 0x1f, 0x31, 0xf4, 0x46, 0x0e, 0x6e, 0xcb, 0x67, 0x32, 0x00, 0x61,
0x20, 0xac, 0xdf, 0x84, 0xe5, 0xaf, 0x08, 0x65, 0x51, 0x1a, 0xc4, 0xd0, 0xac, 0x81, 0xba, 0x4b,
0x3a, 0x0c, 0x87, 0xc2, 0x5b, 0x4b, 0xce, 0xa2, 0xa4, 0x49, 0xc8, 0xc6, 0x6f, 0x23, 0xcb, 0x29,
0xbe, 0xa4, 0x70, 0xc6, 0x98, 0x7e, 0xac, 0x10, 0xd5, 0x5f, 0x2a, 0x50, 0xfc, 0x92, 0x74, 0x3a,
0x17, 0x0d, 0x12, 0x27, 0x1c, 0xd2, 0x8e, 0x68, 0x45, 0xe4, 0x96, 0x9c, 0x45, 0xa9, 0x68, 0x77,
0x3a, 0x3c, 0xa3, 0xf2, 0x56, 0x34, 0xd4, 0xff, 0x55, 0x00, 0x45, 0xca, 0x6f, 0x20, 0x4b, 0x62,
0x4e, 0x4c, 0x8d, 0xe7, 0xc4, 0xf4, 0x04, 0x4e, 0xcc, 0x4c, 0xe4, 0xc4, 0xec, 0x10, 0x27, 0xd6,
0x20, 0x43, 0x03, 0xec, 0x70, 0x16, 0x9d, 0x44, 0x69, 0x5c, 0x22, 0x89, 0x52, 0x6e, 0x62, 0x2a,
0x5d, 0x83, 0xb7, 0xce, 0x5c, 0x5d, 0x44, 0x56, 0xff, 0x45, 0x81, 0x65, 0x0b, 0x53, 0xf2, 0x03,
0xde, 0x66, 0x47, 0x17, 0x1e, 0xaa, 0x55, 0xc8, 0xbe, 0x20, 0x2e, 0xdb, 0x93, 0x91, 0x12, 0x93,
0x08, 0x9d, 0x3d, 0x4c, 0xda, 0x7b, 0xe2, 0xf5, 0x2f, 0x59, 0x72, 0xa6, 0xff, 0x04, 0x57, 0x36,
0x3a, 0x3e, 0xc5, 0xcd, 0x47, 0xff, 0x87, 0x63, 0x22, 0x9c, 0x69, 0x1e, 0x05, 0x31, 0xd1, 0xbf,
0x80, 0xe5, 0x6d, 0xbb, 0x47, 0x17, 0xe6, 0xcf, 0x2d, 0x58, 0xb1, 0x30, 0xed, 0x75, 0x17, 0x36,
0xb4, 0x09, 0x57, 0xa3, 0xc7, 0xb9, 0x4d, 0xdc, 0x45, 0x92, 0x57, 0x7f, 0x5f, 0xf0, 0x81, 0x30,
0x23, 0x9f, 0x38, 0x82, 0x4c, 0x40, 0x5c, 0xf1, 0xc2, 0x97, 0x2c, 0x3e, 0xd6, 0xff, 0x54, 0xe0,
0xda, 0x46, 0x5c, 0x67, 0x17, 0xed, 0x3b, 0x5a, 0xb0, 0x12, 0xd8, 0x21, 0xf6, 0x58, 0x2b, 0x51,
0xeb, 0x45, 0x48, 0xea, 0x11, 0xa7, 0xff, 0x71, 0x52, 0xb9, 0x99, 0xe8, 0xa0, 0xfc, 0x00, 0x7b,
0xb1, 0x3a, 0x35, 0xdb, 0xfe, 0x2d, 0x97, 0xb4, 0x31, 0x65, 0x46, 0x83, 0xff, 0xb3, 0x96, 0x85,
0xb1, 0x8d, 0xb1, 0x7d, 0x40, 0x7a, 0x9e, 0x3e, 0xe0, 0x3b, 0x58, 0x1b, 0xbe, 0x9d, 0x04, 0xe3,
0x73, 0x28, 0x9e, 0x76, 0x77, 0x63, 0x59, 0x6f, 0xa4, 0x21, 0x49, 0x2a, 0xe8, 0x3f, 0xc2, 0xca,
0x37, 0x81, 0xfb, 0x06, 0x7a, 0xb5, 0x3a, 0x14, 0x42, 0x4c, 0xfd, 0x5e, 0xe8, 0x60, 0xca, 0xb1,
0x9a, 0x74, 0xa9, 0x53, 0xb1, 0xfa, 0x3f, 0x45, 0xc8, 0x72, 0xfa, 0x46, 0xfb, 0xa0, 0x8a, 0x46,
0x07, 0x99, 0xc6, 0xb4, 0xb6, 0xdd, 0x18, 0x69, 0x2c, 0xb5, 0x8f, 0xe7, 0x57, 0x90, 0x98, 0x7d,
0x0f, 0x59, 0xde, 0x90, 0xa0, 0x9b, 0xd3, 0x55, 0x93, 0xed, 0x91, 0xf6, 0xe1, 0x5c, 0xb2, 0xf2,
0x84, 0x36, 0xa8, 0xa2, 0xca, 0xcf, 0xba, 0xce, 0x48, 0xd7, 0xa3, 0x7d, 0x34, 0x8f, 0x42, 0x7c,
0xd0, 0x73, 0x58, 0x3a, 0xd3, 0x4e, 0xa0, 0xfa, 0x3c, 0xea, 0x67, 0xab, 0xca, 0x39, 0x8f, 0x7c,
0x06, 0xe9, 0x2d, 0xcc, 0x50, 0x6d, 0xba, 0xd2, 0x69, 0xcf, 0xa1, 0x7d, 0x30, 0x87, 0x64, 0x8c,
0x5b, 0x26, 0x7a, 0xee, 0xc8, 0x98, 0xae, 0x32, 0xdc, 0x22, 0x68, 0xe6, 0xdc, 0xf2, 0xf2, 0xa0,
0x26, 0x64, 0xa2, 0x8a, 0x8f, 0x66, 0xf8, 0x96, 0xe8, 0x0a, 0xb4, 0xb5, 0x91, 0x6c, 0xde, 0x8c,
0x7e, 0x31, 0xa2, 0x6d, 0xc8, 0x44, 0x14, 0x8d, 0x66, 0xe4, 0xe1, 0x68, 0x35, 0x9f, 0x68, 0xf1,
0x09, 0x14, 0xe2, 0x42, 0x37, 0x0b, 0x8a, 0xe1, 0x8a, 0x38, 0xd1, 0xe8, 0x23, 0xc8, 0xc9, 0x12,
0x85, 0x66, 0xc4, 0xfb, 0x6c, 0x25, 0x9b, 0x62, 0x30, 0xcb, 0x4b, 0xce, 0x2c, 0x0f, 0x87, 0xeb,
0xd2, 0x44, 0x83, 0x8f, 0x41, 0x15, 0xb5, 0x67, 0xd6, 0xa3, 0x19, 0xa9, 0x50, 0x13, 0x4d, 0x12,
0xc8, 0x0f, 0xca, 0x07, 0xba, 0x35, 0x3b, 0x47, 0x12, 0xd5, 0x4a, 0x33, 0xe6, 0x15, 0x97, 0x19,
0xf5, 0x02, 0x20, 0x41, 0xf0, 0x77, 0x66, 0x40, 0x3c, 0xae, 0x54, 0x69, 0x9f, 0x9c, 0x4f, 0x49,
0x1e, 0xfc, 0x18, 0x54, 0xc1, 0xe0, 0xb3, 0x60, 0x1b, 0xe1, 0xf9, 0x89, 0xb0, 0x7d, 0x0d, 0xb9,
0x87, 0xe2, 0x63, 0x03, 0xaa, 0x8e, 0xf9, 0xc9, 0x2d, 0xb6, 0x06, 0x46, 0x6e, 0x4c, 0x91, 0x10,
0x2e, 0xae, 0x7f, 0x7b, 0xfc, 0xaa, 0x7c, 0xe9, 0xf7, 0x57, 0xe5, 0x4b, 0x3f, 0xf7, 0xcb, 0xca,
0x71, 0xbf, 0xac, 0xfc, 0xd6, 0x2f, 0x2b, 0x7f, 0xf7, 0xcb, 0xca, 0xb3, 0xfb, 0xaf, 0xf7, 0x9d,
0xe7, 0x1e, 0x1f, 0xec, 0xa8, 0xdc, 0xef, 0x3b, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0x63, 0x7a,
0xe4, 0x79, 0x2e, 0x12, 0x00, 0x00,
}

3
api/services/tasks/v1/tasks.proto
View File

@ -6,6 +6,7 @@ import "google/protobuf/empty.proto";
import "google/protobuf/any.proto";
import "gogoproto/gogo.proto";
import "github.com/containerd/containerd/api/types/mount.proto";
import "github.com/containerd/containerd/api/types/metrics.proto";
import "github.com/containerd/containerd/api/types/descriptor.proto";
import "github.com/containerd/containerd/api/types/task/task.proto";
import "google/protobuf/timestamp.proto";
@ -46,6 +47,8 @@ service Tasks {
rpc Checkpoint(CheckpointTaskRequest) returns (CheckpointTaskResponse);
rpc Update(UpdateTaskRequest) returns (google.protobuf.Empty);
rpc Metrics(types.MetricsRequest) returns (types.MetricsResponse);
}
message CreateTaskRequest {

4
api/types/descriptor.pb.go
View File

@ -7,10 +7,14 @@
It is generated from these files:
github.com/containerd/containerd/api/types/descriptor.proto
github.com/containerd/containerd/api/types/metrics.proto
github.com/containerd/containerd/api/types/mount.proto
It has these top-level messages:
Descriptor
MetricsRequest
MetricsResponse
Metric
Mount
*/
package types

676
api/types/metrics.pb.go Normal file
View File

@ -0,0 +1,676 @@
// Code generated by protoc-gen-gogo.
// source: github.com/containerd/containerd/api/types/metrics.proto
// DO NOT EDIT!
package types
import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"
import google_protobuf1 "github.com/gogo/protobuf/types"
import _ "github.com/gogo/protobuf/types"
import time "time"
import github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
import strings "strings"
import reflect "reflect"
import io "io"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
var _ = time.Kitchen
type MetricsRequest struct {
Filters []string `protobuf:"bytes,1,rep,name=filters" json:"filters,omitempty"`
}
func (m *MetricsRequest) Reset() { *m = MetricsRequest{} }
func (*MetricsRequest) ProtoMessage() {}
func (*MetricsRequest) Descriptor() ([]byte, []int) { return fileDescriptorMetrics, []int{0} }
type MetricsResponse struct {
Metrics []*Metric `protobuf:"bytes,1,rep,name=metrics" json:"metrics,omitempty"`
}
func (m *MetricsResponse) Reset() { *m = MetricsResponse{} }
func (*MetricsResponse) ProtoMessage() {}
func (*MetricsResponse) Descriptor() ([]byte, []int) { return fileDescriptorMetrics, []int{1} }
type Metric struct {
Timestamp time.Time `protobuf:"bytes,1,opt,name=timestamp,stdtime" json:"timestamp"`
Data *google_protobuf1.Any `protobuf:"bytes,2,opt,name=data" json:"data,omitempty"`
}
func (m *Metric) Reset() { *m = Metric{} }
func (*Metric) ProtoMessage() {}
func (*Metric) Descriptor() ([]byte, []int) { return fileDescriptorMetrics, []int{2} }
func init() {
proto.RegisterType((*MetricsRequest)(nil), "containerd.types.MetricsRequest")
proto.RegisterType((*MetricsResponse)(nil), "containerd.types.MetricsResponse")
proto.RegisterType((*Metric)(nil), "containerd.types.Metric")
}
func (m *MetricsRequest) 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 *MetricsRequest) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.Filters) > 0 {
for _, s := range m.Filters {
dAtA[i] = 0xa
i++
l = len(s)
for l >= 1<<7 {
dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
l >>= 7
i++
}
dAtA[i] = uint8(l)
i++
i += copy(dAtA[i:], s)
}
}
return i, nil
}
func (m *MetricsResponse) 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 *MetricsResponse) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.Metrics) > 0 {
for _, msg := range m.Metrics {
dAtA[i] = 0xa
i++
i = encodeVarintMetrics(dAtA, i, uint64(msg.Size()))
n, err := msg.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n
}
}
return i, nil
}
func (m *Metric) 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 *Metric) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
dAtA[i] = 0xa
i++
i = encodeVarintMetrics(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp)))
n1, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i:])
if err != nil {
return 0, err
}
i += n1
if m.Data != nil {
dAtA[i] = 0x12
i++
i = encodeVarintMetrics(dAtA, i, uint64(m.Data.Size()))
n2, err := m.Data.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n2
}
return i, nil
}
func encodeFixed64Metrics(dAtA []byte, offset int, v uint64) int {
dAtA[offset] = uint8(v)
dAtA[offset+1] = uint8(v >> 8)
dAtA[offset+2] = uint8(v >> 16)
dAtA[offset+3] = uint8(v >> 24)
dAtA[offset+4] = uint8(v >> 32)
dAtA[offset+5] = uint8(v >> 40)
dAtA[offset+6] = uint8(v >> 48)
dAtA[offset+7] = uint8(v >> 56)
return offset + 8
}
func encodeFixed32Metrics(dAtA []byte, offset int, v uint32) int {
dAtA[offset] = uint8(v)
dAtA[offset+1] = uint8(v >> 8)
dAtA[offset+2] = uint8(v >> 16)
dAtA[offset+3] = uint8(v >> 24)
return offset + 4
}
func encodeVarintMetrics(dAtA []byte, offset int, v uint64) int {
for v >= 1<<7 {
dAtA[offset] = uint8(v&0x7f | 0x80)
v >>= 7
offset++
}
dAtA[offset] = uint8(v)
return offset + 1
}
func (m *MetricsRequest) Size() (n int) {
var l int
_ = l
if len(m.Filters) > 0 {
for _, s := range m.Filters {
l = len(s)
n += 1 + l + sovMetrics(uint64(l))
}
}
return n
}
func (m *MetricsResponse) Size() (n int) {
var l int
_ = l
if len(m.Metrics) > 0 {
for _, e := range m.Metrics {
l = e.Size()
n += 1 + l + sovMetrics(uint64(l))
}
}
return n
}
func (m *Metric) Size() (n int) {
var l int
_ = l
l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp)
n += 1 + l + sovMetrics(uint64(l))
if m.Data != nil {
l = m.Data.Size()
n += 1 + l + sovMetrics(uint64(l))
}
return n
}
func sovMetrics(x uint64) (n int) {
for {
n++
x >>= 7
if x == 0 {
break
}
}
return n
}
func sozMetrics(x uint64) (n int) {
return sovMetrics(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *MetricsRequest) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&MetricsRequest{`,
`Filters:` + fmt.Sprintf("%v", this.Filters) + `,`,
`}`,
}, "")
return s
}
func (this *MetricsResponse) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&MetricsResponse{`,
`Metrics:` + strings.Replace(fmt.Sprintf("%v", this.Metrics), "Metric", "Metric", 1) + `,`,
`}`,
}, "")
return s
}
func (this *Metric) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&Metric{`,
`Timestamp:` + strings.Replace(strings.Replace(this.Timestamp.String(), "Timestamp", "google_protobuf2.Timestamp", 1), `&`, ``, 1) + `,`,
`Data:` + strings.Replace(fmt.Sprintf("%v", this.Data), "Any", "google_protobuf1.Any", 1) + `,`,
`}`,
}, "")
return s
}
func valueToStringMetrics(v interface{}) string {
rv := reflect.ValueOf(v)
if rv.IsNil() {
return "nil"
}
pv := reflect.Indirect(rv).Interface()
return fmt.Sprintf("*%v", pv)
}
func (m *MetricsRequest) 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 ErrIntOverflowMetrics
}
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: MetricsRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: MetricsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Filters", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowMetrics
}
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 ErrInvalidLengthMetrics
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Filters = append(m.Filters, string(dAtA[iNdEx:postIndex]))
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipMetrics(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthMetrics
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *MetricsResponse) 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 ErrIntOverflowMetrics
}
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: MetricsResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: MetricsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Metrics", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowMetrics
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthMetrics
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Metrics = append(m.Metrics, &Metric{})
if err := m.Metrics[len(m.Metrics)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipMetrics(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthMetrics
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Metric) 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 ErrIntOverflowMetrics
}
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: Metric: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Metric: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowMetrics
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthMetrics
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowMetrics
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthMetrics
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Data == nil {
m.Data = &google_protobuf1.Any{}
}
if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipMetrics(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthMetrics
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipMetrics(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowMetrics
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
wireType := int(wire & 0x7)
switch wireType {
case 0:
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowMetrics
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
iNdEx++
if dAtA[iNdEx-1] < 0x80 {
break
}
}
return iNdEx, nil
case 1:
iNdEx += 8
return iNdEx, nil
case 2:
var length int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowMetrics
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
length |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
iNdEx += length
if length < 0 {
return 0, ErrInvalidLengthMetrics
}
return iNdEx, nil
case 3:
for {
var innerWire uint64
var start int = iNdEx
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowMetrics
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
innerWire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
innerWireType := int(innerWire & 0x7)
if innerWireType == 4 {
break
}
next, err := skipMetrics(dAtA[start:])
if err != nil {
return 0, err
}
iNdEx = start + next
}
return iNdEx, nil
case 4:
return iNdEx, nil
case 5:
iNdEx += 4
return iNdEx, nil
default:
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
}
}
panic("unreachable")
}
var (
ErrInvalidLengthMetrics = fmt.Errorf("proto: negative length found during unmarshaling")
ErrIntOverflowMetrics = fmt.Errorf("proto: integer overflow")
)
func init() {
proto.RegisterFile("github.com/containerd/containerd/api/types/metrics.proto", fileDescriptorMetrics)
}
var fileDescriptorMetrics = []byte{
// 297 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xb2, 0x48, 0xcf, 0x2c, 0xc9,
0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xce, 0xcf, 0x2b, 0x49, 0xcc, 0xcc, 0x4b, 0x2d,
0x4a, 0x41, 0x66, 0x26, 0x16, 0x64, 0xea, 0x97, 0x54, 0x16, 0xa4, 0x16, 0xeb, 0xe7, 0xa6, 0x96,
0x14, 0x65, 0x26, 0x17, 0xeb, 0x15, 0x14, 0xe5, 0x97, 0xe4, 0x0b, 0x09, 0x20, 0xd4, 0xe8, 0x81,
0xe5, 0xa5, 0x44, 0xd2, 0xf3, 0xd3, 0xf3, 0xc1, 0x92, 0xfa, 0x20, 0x16, 0x44, 0x9d, 0x94, 0x64,
0x7a, 0x7e, 0x7e, 0x7a, 0x4e, 0xaa, 0x3e, 0x98, 0x97, 0x54, 0x9a, 0xa6, 0x9f, 0x98, 0x57, 0x09,
0x95, 0x92, 0x47, 0x97, 0x2a, 0xc9, 0xcc, 0x4d, 0x2d, 0x2e, 0x49, 0xcc, 0x2d, 0x80, 0x28, 0x50,
0xd2, 0xe2, 0xe2, 0xf3, 0x85, 0x58, 0x1a, 0x94, 0x5a, 0x58, 0x9a, 0x5a, 0x5c, 0x22, 0x24, 0xc1,
0xc5, 0x9e, 0x96, 0x99, 0x53, 0x92, 0x5a, 0x54, 0x2c, 0xc1, 0xa8, 0xc0, 0xac, 0xc1, 0x19, 0x04,
0xe3, 0x2a, 0xb9, 0x72, 0xf1, 0xc3, 0xd5, 0x16, 0x17, 0xe4, 0xe7, 0x15, 0xa7, 0x0a, 0x19, 0x71,
0xb1, 0x43, 0xdd, 0x0c, 0x56, 0xcc, 0x6d, 0x24, 0xa1, 0x87, 0xee, 0x68, 0x3d, 0x88, 0x9e, 0x20,
0x98, 0x42, 0xa5, 0x32, 0x2e, 0x36, 0x88, 0x90, 0x90, 0x13, 0x17, 0x27, 0xdc, 0x3d, 0x12, 0x8c,
0x0a, 0x8c, 0x1a, 0xdc, 0x46, 0x52, 0x7a, 0x10, 0x17, 0xeb, 0xc1, 0x5c, 0xac, 0x17, 0x02, 0x53,
0xe1, 0xc4, 0x71, 0xe2, 0x9e, 0x3c, 0xc3, 0x84, 0xfb, 0xf2, 0x8c, 0x41, 0x08, 0x6d, 0x42, 0x1a,
0x5c, 0x2c, 0x29, 0x89, 0x25, 0x89, 0x12, 0x4c, 0x60, 0xed, 0x22, 0x18, 0xda, 0x1d, 0xf3, 0x2a,
0x83, 0xc0, 0x2a, 0x9c, 0xbc, 0x4e, 0x3c, 0x94, 0x63, 0xb8, 0xf1, 0x50, 0x8e, 0xa1, 0xe1, 0x91,
0x1c, 0xe3, 0x89, 0x47, 0x72, 0x8c, 0x17, 0x1e, 0xc9, 0x31, 0x3e, 0x78, 0x24, 0xc7, 0x18, 0x65,
0x40, 0x7c, 0x14, 0x59, 0x83, 0xc9, 0x24, 0x36, 0xb0, 0xf9, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff,
0xff, 0xa5, 0x43, 0x7b, 0x37, 0xdd, 0x01, 0x00, 0x00,
}

22
api/types/metrics.proto Normal file
View File

@ -0,0 +1,22 @@
syntax = "proto3";
package containerd.types;
import "gogoproto/gogo.proto";
import "google/protobuf/any.proto";
import "google/protobuf/timestamp.proto";
option go_package = "github.com/containerd/containerd/api/types;types";
message MetricsRequest {
repeated string filters = 1;
}
message MetricsResponse {
repeated Metric metrics = 1;
}
message Metric {
google.protobuf.Timestamp timestamp = 1 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
google.protobuf.Any data = 2;
}

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

@ -5,17 +5,31 @@ file {
message_type {
name: "RuncOptions"
field {
name: "criu_path"
name: "runtime"
number: 1
label: LABEL_OPTIONAL
type: TYPE_STRING
json_name: "runtime"
}
field {
name: "runtime_root"
number: 2
label: LABEL_OPTIONAL
type: TYPE_STRING
json_name: "runtimeRoot"
}
field {
name: "criu_path"
number: 3
label: LABEL_OPTIONAL
type: TYPE_STRING
json_name: "criuPath"
}
field {
name: "systemd_cgroup"
number: 2
number: 4
label: LABEL_OPTIONAL
type: TYPE_STRING
type: TYPE_BOOL
json_name: "systemdCgroup"
}
}

5
linux/runtime.go
View File

@ -245,7 +245,10 @@ func (r *Runtime) Create(ctx context.Context, id string, opts runtime.CreateOpts
if err != nil {
return nil, errdefs.FromGRPC(err)
}
t := newTask(id, namespace, int(cr.Pid), s)
t, err := newTask(id, namespace, int(cr.Pid), s)
if err != nil {
return nil, err
}
if err := r.tasks.Add(ctx, t); err != nil {
return nil, err
}

15
linux/task.go
View File

@ -5,6 +5,7 @@ package linux
import (
"context"
"github.com/containerd/cgroups"
"github.com/containerd/containerd/api/types/task"
"github.com/containerd/containerd/errdefs"
client "github.com/containerd/containerd/linux/shim"
@ -18,15 +19,21 @@ type Task struct {
pid int
shim *client.Client
namespace string
cg *cgroups.Cgroup
}
func newTask(id, namespace string, pid int, shim *client.Client) *Task {
func newTask(id, namespace string, pid int, shim *client.Client) (*Task, error) {
cg, err := cgroups.Load(cgroups.V1, cgroups.PidPath(pid))
if err != nil {
return nil, err
}
return &Task{
id: id,
pid: pid,
shim: shim,
namespace: namespace,
}
cg: cg,
}, nil
}
func (t *Task) ID() string {
@ -201,3 +208,7 @@ func (t *Task) Process(ctx context.Context, id string) (runtime.Process, error)
t: t,
}, nil
}
func (t *Task) Metrics(ctx context.Context) (interface{}, error) {
return nil, nil
}

11
metrics/cgroups/cgroups.go
View File

@ -11,7 +11,6 @@ import (
"github.com/containerd/containerd/plugin"
"github.com/containerd/containerd/runtime"
metrics "github.com/docker/go-metrics"
"github.com/pkg/errors"
"golang.org/x/net/context"
)
@ -50,15 +49,7 @@ type cgroupsMonitor struct {
func (m *cgroupsMonitor) Monitor(c runtime.Task) error {
info := c.Info()
state, err := c.State(m.context)
if err != nil {
return err
}
cg, err := cgroups.Load(cgroups.V1, cgroups.PidPath(int(state.Pid)))
if err != nil {
return errors.Wrapf(err, "load cgroup for %d", state.Pid)
}
if err := m.collector.Add(info.ID, info.Namespace, cg); err != nil {
if err := m.collector.Add(info.ID, info.Namespace, c); err != nil {
return err
}
return m.oom.Add(info.ID, info.Namespace, cg, m.trigger)

2
runtime/task.go
View File

@ -49,6 +49,8 @@ type Task interface {
Update(context.Context, *types.Any) error
// Process returns a process within the task for the provided id
Process(context.Context, string) (Process, error)
// Metrics returns runtime specific metrics for a task
Metrics(context.Context) (interface{}, error)
}
type ExecOpts struct {

30
services/tasks/service.go
View File

@ -7,6 +7,7 @@ import (
"io/ioutil"
"os"
"path/filepath"
"time"
"github.com/boltdb/bolt"
api "github.com/containerd/containerd/api/services/tasks/v1"
@ -23,6 +24,7 @@ import (
"github.com/containerd/containerd/mount"
"github.com/containerd/containerd/plugin"
"github.com/containerd/containerd/runtime"
"github.com/containerd/containerd/typeurl"
google_protobuf "github.com/golang/protobuf/ptypes/empty"
"golang.org/x/net/context"
"google.golang.org/grpc"
@ -454,6 +456,34 @@ func (s *Service) Update(ctx context.Context, r *api.UpdateTaskRequest) (*google
return empty, nil
}
func (s *Service) Metrics(ctx context.Context, r *types.MetricsRequest) (*types.MetricsResponse, error) {
var resp types.MetricsResponse
for _, r := range s.runtimes {
tasks, err := r.Tasks(ctx)
if err != nil {
return nil, err
}
for _, t := range tasks {
collected := time.Now()
metrics, err := t.Metrics(ctx)
if err != nil {
log.G(ctx).WithError(err).Errorf("collecting metrics for %s", t.ID())
continue
}
data, err := typeurl.MarshalAny(metrics)
if err != nil {
log.G(ctx).WithError(err).Errorf("marshal metrics for %s", t.ID())
continue
}
resp.Metrics = append(resp.Metrics, &types.Metric{
Timestamp: collected,
Data: data,
})
}
}
return &resp, nil
}
func (s *Service) writeContent(ctx context.Context, mediaType, ref string, r io.Reader) (*types.Descriptor, error) {
writer, err := s.store.Writer(ctx, ref, 0, "")
if err != nil {