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

Update GRPC for consistency

Browse Source 
Signed-off-by: Michael Crosby <crosbymichael@gmail.com>
This commit is contained in:
Michael Crosby 2017-06-20 17:47:59 -07:00
parent 13e7d3c393
commit 94eafaab60
56 changed files with 3941 additions and 2802 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

531
api/services/containers/containers.pb.go
View File

@ -75,9 +75,9 @@ type Container struct {
// If this field is updated, the spec and rootfs needed to updated, as well. // If this field is updated, the spec and rootfs needed to updated, as well.
Image string `protobuf:"bytes,3,opt,name=image,proto3" json:"image,omitempty"` Image string `protobuf:"bytes,3,opt,name=image,proto3" json:"image,omitempty"`
// Runtime specifies which runtime to use for executing this container. // Runtime specifies which runtime to use for executing this container.
Runtime string `protobuf:"bytes,4,opt,name=runtime,proto3" json:"runtime,omitempty"` Runtime *Container_Runtime `protobuf:"bytes,4,opt,name=runtime" json:"runtime,omitempty"`
// Spec to be used when creating the container. This is runtime specific. // Spec to be used when creating the container. This is runtime specific.
Spec *google_protobuf1.Any `protobuf:"bytes,6,opt,name=spec" json:"spec,omitempty"` Spec *google_protobuf1.Any `protobuf:"bytes,5,opt,name=spec" json:"spec,omitempty"`
// RootFS specifies the snapshot key to use for the container's root // RootFS specifies the snapshot key to use for the container's root
// filesystem. When starting a task from this container, a caller should // filesystem. When starting a task from this container, a caller should
// look up the mounts from the snapshot service and include those on the // look up the mounts from the snapshot service and include those on the
@ -86,15 +86,28 @@ type Container struct {
// Snapshots referenced in this field will not be garbage collected. // Snapshots referenced in this field will not be garbage collected.
// //
// This field may be updated. // This field may be updated.
RootFS string `protobuf:"bytes,7,opt,name=rootfs,proto3" json:"rootfs,omitempty"` RootFS string `protobuf:"bytes,6,opt,name=rootfs,proto3" json:"rootfs,omitempty"`
CreatedAt time.Time `protobuf:"bytes,8,opt,name=created_at,json=createdAt,stdtime" json:"created_at"` // CreatedAt is the time the container was first created.
UpdatedAt time.Time `protobuf:"bytes,9,opt,name=updated_at,json=updatedAt,stdtime" json:"updated_at"` CreatedAt time.Time `protobuf:"bytes,7,opt,name=created_at,json=createdAt,stdtime" json:"created_at"`
// UpdatedAt is the last time the container was mutated.
UpdatedAt time.Time `protobuf:"bytes,8,opt,name=updated_at,json=updatedAt,stdtime" json:"updated_at"`
} }
func (m *Container) Reset() { *m = Container{} } func (m *Container) Reset() { *m = Container{} }
func (*Container) ProtoMessage() {} func (*Container) ProtoMessage() {}
func (*Container) Descriptor() ([]byte, []int) { return fileDescriptorContainers, []int{0} } func (*Container) Descriptor() ([]byte, []int) { return fileDescriptorContainers, []int{0} }
type Container_Runtime struct {
// Name is the name of the runtime.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// Options specify additional runtime initialization options.
Options map[string]string `protobuf:"bytes,2,rep,name=options" json:"options,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (m *Container_Runtime) Reset() { *m = Container_Runtime{} }
func (*Container_Runtime) ProtoMessage() {}
func (*Container_Runtime) Descriptor() ([]byte, []int) { return fileDescriptorContainers, []int{0, 1} }
type GetContainerRequest struct { type GetContainerRequest 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"`
} }
@ -183,16 +196,17 @@ func (*DeleteContainerRequest) ProtoMessage() {}
func (*DeleteContainerRequest) Descriptor() ([]byte, []int) { return fileDescriptorContainers, []int{9} } func (*DeleteContainerRequest) Descriptor() ([]byte, []int) { return fileDescriptorContainers, []int{9} }
func init() { func init() {
proto.RegisterType((*Container)(nil), "containerd.v1.Container") proto.RegisterType((*Container)(nil), "containerd.services.containers.v1.Container")
proto.RegisterType((*GetContainerRequest)(nil), "containerd.v1.GetContainerRequest") proto.RegisterType((*Container_Runtime)(nil), "containerd.services.containers.v1.Container.Runtime")
proto.RegisterType((*GetContainerResponse)(nil), "containerd.v1.GetContainerResponse") proto.RegisterType((*GetContainerRequest)(nil), "containerd.services.containers.v1.GetContainerRequest")
proto.RegisterType((*ListContainersRequest)(nil), "containerd.v1.ListContainersRequest") proto.RegisterType((*GetContainerResponse)(nil), "containerd.services.containers.v1.GetContainerResponse")
proto.RegisterType((*ListContainersResponse)(nil), "containerd.v1.ListContainersResponse") proto.RegisterType((*ListContainersRequest)(nil), "containerd.services.containers.v1.ListContainersRequest")
proto.RegisterType((*CreateContainerRequest)(nil), "containerd.v1.CreateContainerRequest") proto.RegisterType((*ListContainersResponse)(nil), "containerd.services.containers.v1.ListContainersResponse")
proto.RegisterType((*CreateContainerResponse)(nil), "containerd.v1.CreateContainerResponse") proto.RegisterType((*CreateContainerRequest)(nil), "containerd.services.containers.v1.CreateContainerRequest")
proto.RegisterType((*UpdateContainerRequest)(nil), "containerd.v1.UpdateContainerRequest") proto.RegisterType((*CreateContainerResponse)(nil), "containerd.services.containers.v1.CreateContainerResponse")
proto.RegisterType((*UpdateContainerResponse)(nil), "containerd.v1.UpdateContainerResponse") proto.RegisterType((*UpdateContainerRequest)(nil), "containerd.services.containers.v1.UpdateContainerRequest")
proto.RegisterType((*DeleteContainerRequest)(nil), "containerd.v1.DeleteContainerRequest") proto.RegisterType((*UpdateContainerResponse)(nil), "containerd.services.containers.v1.UpdateContainerResponse")
proto.RegisterType((*DeleteContainerRequest)(nil), "containerd.services.containers.v1.DeleteContainerRequest")
} }
// Reference imports to suppress errors if they are not otherwise used. // Reference imports to suppress errors if they are not otherwise used.
@ -223,7 +237,7 @@ func NewContainersClient(cc *grpc.ClientConn) ContainersClient {
func (c *containersClient) Get(ctx context.Context, in *GetContainerRequest, opts ...grpc.CallOption) (*GetContainerResponse, error) { func (c *containersClient) Get(ctx context.Context, in *GetContainerRequest, opts ...grpc.CallOption) (*GetContainerResponse, error) {
out := new(GetContainerResponse) out := new(GetContainerResponse)
err := grpc.Invoke(ctx, "/containerd.v1.Containers/Get", in, out, c.cc, opts...) err := grpc.Invoke(ctx, "/containerd.services.containers.v1.Containers/Get", in, out, c.cc, opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -232,7 +246,7 @@ func (c *containersClient) Get(ctx context.Context, in *GetContainerRequest, opt
func (c *containersClient) List(ctx context.Context, in *ListContainersRequest, opts ...grpc.CallOption) (*ListContainersResponse, error) { func (c *containersClient) List(ctx context.Context, in *ListContainersRequest, opts ...grpc.CallOption) (*ListContainersResponse, error) {
out := new(ListContainersResponse) out := new(ListContainersResponse)
err := grpc.Invoke(ctx, "/containerd.v1.Containers/List", in, out, c.cc, opts...) err := grpc.Invoke(ctx, "/containerd.services.containers.v1.Containers/List", in, out, c.cc, opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -241,7 +255,7 @@ func (c *containersClient) List(ctx context.Context, in *ListContainersRequest,
func (c *containersClient) Create(ctx context.Context, in *CreateContainerRequest, opts ...grpc.CallOption) (*CreateContainerResponse, error) { func (c *containersClient) Create(ctx context.Context, in *CreateContainerRequest, opts ...grpc.CallOption) (*CreateContainerResponse, error) {
out := new(CreateContainerResponse) out := new(CreateContainerResponse)
err := grpc.Invoke(ctx, "/containerd.v1.Containers/Create", in, out, c.cc, opts...) err := grpc.Invoke(ctx, "/containerd.services.containers.v1.Containers/Create", in, out, c.cc, opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -250,7 +264,7 @@ func (c *containersClient) Create(ctx context.Context, in *CreateContainerReques
func (c *containersClient) Update(ctx context.Context, in *UpdateContainerRequest, opts ...grpc.CallOption) (*UpdateContainerResponse, error) { func (c *containersClient) Update(ctx context.Context, in *UpdateContainerRequest, opts ...grpc.CallOption) (*UpdateContainerResponse, error) {
out := new(UpdateContainerResponse) out := new(UpdateContainerResponse)
err := grpc.Invoke(ctx, "/containerd.v1.Containers/Update", in, out, c.cc, opts...) err := grpc.Invoke(ctx, "/containerd.services.containers.v1.Containers/Update", in, out, c.cc, opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -259,7 +273,7 @@ func (c *containersClient) Update(ctx context.Context, in *UpdateContainerReques
func (c *containersClient) Delete(ctx context.Context, in *DeleteContainerRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error) { func (c *containersClient) Delete(ctx context.Context, in *DeleteContainerRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error) {
out := new(google_protobuf2.Empty) out := new(google_protobuf2.Empty)
err := grpc.Invoke(ctx, "/containerd.v1.Containers/Delete", in, out, c.cc, opts...) err := grpc.Invoke(ctx, "/containerd.services.containers.v1.Containers/Delete", in, out, c.cc, opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -290,7 +304,7 @@ func _Containers_Get_Handler(srv interface{}, ctx context.Context, dec func(inte
} }
info := &grpc.UnaryServerInfo{ info := &grpc.UnaryServerInfo{
Server: srv, Server: srv,
FullMethod: "/containerd.v1.Containers/Get", FullMethod: "/containerd.services.containers.v1.Containers/Get",
} }
handler := func(ctx context.Context, req interface{}) (interface{}, error) { handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ContainersServer).Get(ctx, req.(*GetContainerRequest)) return srv.(ContainersServer).Get(ctx, req.(*GetContainerRequest))
@ -308,7 +322,7 @@ func _Containers_List_Handler(srv interface{}, ctx context.Context, dec func(int
} }
info := &grpc.UnaryServerInfo{ info := &grpc.UnaryServerInfo{
Server: srv, Server: srv,
FullMethod: "/containerd.v1.Containers/List", FullMethod: "/containerd.services.containers.v1.Containers/List",
} }
handler := func(ctx context.Context, req interface{}) (interface{}, error) { handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ContainersServer).List(ctx, req.(*ListContainersRequest)) return srv.(ContainersServer).List(ctx, req.(*ListContainersRequest))
@ -326,7 +340,7 @@ func _Containers_Create_Handler(srv interface{}, ctx context.Context, dec func(i
} }
info := &grpc.UnaryServerInfo{ info := &grpc.UnaryServerInfo{
Server: srv, Server: srv,
FullMethod: "/containerd.v1.Containers/Create", FullMethod: "/containerd.services.containers.v1.Containers/Create",
} }
handler := func(ctx context.Context, req interface{}) (interface{}, error) { handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ContainersServer).Create(ctx, req.(*CreateContainerRequest)) return srv.(ContainersServer).Create(ctx, req.(*CreateContainerRequest))
@ -344,7 +358,7 @@ func _Containers_Update_Handler(srv interface{}, ctx context.Context, dec func(i
} }
info := &grpc.UnaryServerInfo{ info := &grpc.UnaryServerInfo{
Server: srv, Server: srv,
FullMethod: "/containerd.v1.Containers/Update", FullMethod: "/containerd.services.containers.v1.Containers/Update",
} }
handler := func(ctx context.Context, req interface{}) (interface{}, error) { handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ContainersServer).Update(ctx, req.(*UpdateContainerRequest)) return srv.(ContainersServer).Update(ctx, req.(*UpdateContainerRequest))
@ -362,7 +376,7 @@ func _Containers_Delete_Handler(srv interface{}, ctx context.Context, dec func(i
} }
info := &grpc.UnaryServerInfo{ info := &grpc.UnaryServerInfo{
Server: srv, Server: srv,
FullMethod: "/containerd.v1.Containers/Delete", FullMethod: "/containerd.services.containers.v1.Containers/Delete",
} }
handler := func(ctx context.Context, req interface{}) (interface{}, error) { handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ContainersServer).Delete(ctx, req.(*DeleteContainerRequest)) return srv.(ContainersServer).Delete(ctx, req.(*DeleteContainerRequest))
@ -371,7 +385,7 @@ func _Containers_Delete_Handler(srv interface{}, ctx context.Context, dec func(i
} }
var _Containers_serviceDesc = grpc.ServiceDesc{ var _Containers_serviceDesc = grpc.ServiceDesc{
ServiceName: "containerd.v1.Containers", ServiceName: "containerd.services.containers.v1.Containers",
HandlerType: (*ContainersServer)(nil), HandlerType: (*ContainersServer)(nil),
Methods: []grpc.MethodDesc{ Methods: []grpc.MethodDesc{
{ {
@ -443,44 +457,89 @@ func (m *Container) MarshalTo(dAtA []byte) (int, error) {
i = encodeVarintContainers(dAtA, i, uint64(len(m.Image))) i = encodeVarintContainers(dAtA, i, uint64(len(m.Image)))
i += copy(dAtA[i:], m.Image) i += copy(dAtA[i:], m.Image)
} }
if len(m.Runtime) > 0 { if m.Runtime != nil {
dAtA[i] = 0x22 dAtA[i] = 0x22
i++ i++
i = encodeVarintContainers(dAtA, i, uint64(len(m.Runtime))) i = encodeVarintContainers(dAtA, i, uint64(m.Runtime.Size()))
i += copy(dAtA[i:], m.Runtime) n1, err := m.Runtime.MarshalTo(dAtA[i:])
}
if m.Spec != nil {
dAtA[i] = 0x32
i++
i = encodeVarintContainers(dAtA, i, uint64(m.Spec.Size()))
n1, err := m.Spec.MarshalTo(dAtA[i:])
if err != nil { if err != nil {
return 0, err return 0, err
} }
i += n1 i += n1
} }
if m.Spec != nil {
dAtA[i] = 0x2a
i++
i = encodeVarintContainers(dAtA, i, uint64(m.Spec.Size()))
n2, err := m.Spec.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n2
}
if len(m.RootFS) > 0 { if len(m.RootFS) > 0 {
dAtA[i] = 0x3a dAtA[i] = 0x32
i++ i++
i = encodeVarintContainers(dAtA, i, uint64(len(m.RootFS))) i = encodeVarintContainers(dAtA, i, uint64(len(m.RootFS)))
i += copy(dAtA[i:], m.RootFS) i += copy(dAtA[i:], m.RootFS)
} }
dAtA[i] = 0x42 dAtA[i] = 0x3a
i++ i++
i = encodeVarintContainers(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt))) i = encodeVarintContainers(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt)))
n2, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CreatedAt, dAtA[i:]) n3, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CreatedAt, dAtA[i:])
if err != nil {
return 0, err
}
i += n2
dAtA[i] = 0x4a
i++
i = encodeVarintContainers(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt)))
n3, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UpdatedAt, dAtA[i:])
if err != nil { if err != nil {
return 0, err return 0, err
} }
i += n3 i += n3
dAtA[i] = 0x42
i++
i = encodeVarintContainers(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt)))
n4, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UpdatedAt, dAtA[i:])
if err != nil {
return 0, err
}
i += n4
return i, nil
}
func (m *Container_Runtime) 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 *Container_Runtime) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.Name) > 0 {
dAtA[i] = 0xa
i++
i = encodeVarintContainers(dAtA, i, uint64(len(m.Name)))
i += copy(dAtA[i:], m.Name)
}
if len(m.Options) > 0 {
for k, _ := range m.Options {
dAtA[i] = 0x12
i++
v := m.Options[k]
mapSize := 1 + len(k) + sovContainers(uint64(len(k))) + 1 + len(v) + sovContainers(uint64(len(v)))
i = encodeVarintContainers(dAtA, i, uint64(mapSize))
dAtA[i] = 0xa
i++
i = encodeVarintContainers(dAtA, i, uint64(len(k)))
i += copy(dAtA[i:], k)
dAtA[i] = 0x12
i++
i = encodeVarintContainers(dAtA, i, uint64(len(v)))
i += copy(dAtA[i:], v)
}
}
return i, nil return i, nil
} }
@ -526,11 +585,11 @@ func (m *GetContainerResponse) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0xa dAtA[i] = 0xa
i++ i++
i = encodeVarintContainers(dAtA, i, uint64(m.Container.Size())) i = encodeVarintContainers(dAtA, i, uint64(m.Container.Size()))
n4, err := m.Container.MarshalTo(dAtA[i:]) n5, err := m.Container.MarshalTo(dAtA[i:])
if err != nil { if err != nil {
return 0, err return 0, err
} }
i += n4 i += n5
return i, nil return i, nil
} }
@ -606,11 +665,11 @@ func (m *CreateContainerRequest) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0xa dAtA[i] = 0xa
i++ i++
i = encodeVarintContainers(dAtA, i, uint64(m.Container.Size())) i = encodeVarintContainers(dAtA, i, uint64(m.Container.Size()))
n5, err := m.Container.MarshalTo(dAtA[i:]) n6, err := m.Container.MarshalTo(dAtA[i:])
if err != nil { if err != nil {
return 0, err return 0, err
} }
i += n5 i += n6
return i, nil return i, nil
} }
@ -632,11 +691,11 @@ func (m *CreateContainerResponse) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0xa dAtA[i] = 0xa
i++ i++
i = encodeVarintContainers(dAtA, i, uint64(m.Container.Size())) i = encodeVarintContainers(dAtA, i, uint64(m.Container.Size()))
n6, err := m.Container.MarshalTo(dAtA[i:]) n7, err := m.Container.MarshalTo(dAtA[i:])
if err != nil { if err != nil {
return 0, err return 0, err
} }
i += n6 i += n7
return i, nil return i, nil
} }
@ -658,20 +717,20 @@ func (m *UpdateContainerRequest) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0xa dAtA[i] = 0xa
i++ i++
i = encodeVarintContainers(dAtA, i, uint64(m.Container.Size())) i = encodeVarintContainers(dAtA, i, uint64(m.Container.Size()))
n7, err := m.Container.MarshalTo(dAtA[i:]) n8, err := m.Container.MarshalTo(dAtA[i:])
if err != nil { if err != nil {
return 0, err return 0, err
} }
i += n7 i += n8
if m.UpdateMask != nil { if m.UpdateMask != nil {
dAtA[i] = 0x12 dAtA[i] = 0x12
i++ i++
i = encodeVarintContainers(dAtA, i, uint64(m.UpdateMask.Size())) i = encodeVarintContainers(dAtA, i, uint64(m.UpdateMask.Size()))
n8, err := m.UpdateMask.MarshalTo(dAtA[i:]) n9, err := m.UpdateMask.MarshalTo(dAtA[i:])
if err != nil { if err != nil {
return 0, err return 0, err
} }
i += n8 i += n9
} }
return i, nil return i, nil
} }
@ -694,11 +753,11 @@ func (m *UpdateContainerResponse) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0xa dAtA[i] = 0xa
i++ i++
i = encodeVarintContainers(dAtA, i, uint64(m.Container.Size())) i = encodeVarintContainers(dAtA, i, uint64(m.Container.Size()))
n9, err := m.Container.MarshalTo(dAtA[i:]) n10, err := m.Container.MarshalTo(dAtA[i:])
if err != nil { if err != nil {
return 0, err return 0, err
} }
i += n9 i += n10
return i, nil return i, nil
} }
@ -772,8 +831,8 @@ func (m *Container) Size() (n int) {
if l > 0 { if l > 0 {
n += 1 + l + sovContainers(uint64(l)) n += 1 + l + sovContainers(uint64(l))
} }
l = len(m.Runtime) if m.Runtime != nil {
if l > 0 { l = m.Runtime.Size()
n += 1 + l + sovContainers(uint64(l)) n += 1 + l + sovContainers(uint64(l))
} }
if m.Spec != nil { if m.Spec != nil {
@ -791,6 +850,24 @@ func (m *Container) Size() (n int) {
return n return n
} }
func (m *Container_Runtime) Size() (n int) {
var l int
_ = l
l = len(m.Name)
if l > 0 {
n += 1 + l + sovContainers(uint64(l))
}
if len(m.Options) > 0 {
for k, v := range m.Options {
_ = k
_ = v
mapEntrySize := 1 + len(k) + sovContainers(uint64(len(k))) + 1 + len(v) + sovContainers(uint64(len(v)))
n += mapEntrySize + 1 + sovContainers(uint64(mapEntrySize))
}
}
return n
}
func (m *GetContainerRequest) Size() (n int) { func (m *GetContainerRequest) Size() (n int) {
var l int var l int
_ = l _ = l
@ -908,7 +985,7 @@ func (this *Container) String() string {
`ID:` + fmt.Sprintf("%v", this.ID) + `,`, `ID:` + fmt.Sprintf("%v", this.ID) + `,`,
`Labels:` + mapStringForLabels + `,`, `Labels:` + mapStringForLabels + `,`,
`Image:` + fmt.Sprintf("%v", this.Image) + `,`, `Image:` + fmt.Sprintf("%v", this.Image) + `,`,
`Runtime:` + fmt.Sprintf("%v", this.Runtime) + `,`, `Runtime:` + strings.Replace(fmt.Sprintf("%v", this.Runtime), "Container_Runtime", "Container_Runtime", 1) + `,`,
`Spec:` + strings.Replace(fmt.Sprintf("%v", this.Spec), "Any", "google_protobuf1.Any", 1) + `,`, `Spec:` + strings.Replace(fmt.Sprintf("%v", this.Spec), "Any", "google_protobuf1.Any", 1) + `,`,
`RootFS:` + fmt.Sprintf("%v", this.RootFS) + `,`, `RootFS:` + fmt.Sprintf("%v", this.RootFS) + `,`,
`CreatedAt:` + strings.Replace(strings.Replace(this.CreatedAt.String(), "Timestamp", "google_protobuf4.Timestamp", 1), `&`, ``, 1) + `,`, `CreatedAt:` + strings.Replace(strings.Replace(this.CreatedAt.String(), "Timestamp", "google_protobuf4.Timestamp", 1), `&`, ``, 1) + `,`,
@ -917,6 +994,27 @@ func (this *Container) String() string {
}, "") }, "")
return s return s
} }
func (this *Container_Runtime) String() string {
if this == nil {
return "nil"
}
keysForOptions := make([]string, 0, len(this.Options))
for k, _ := range this.Options {
keysForOptions = append(keysForOptions, k)
}
github_com_gogo_protobuf_sortkeys.Strings(keysForOptions)
mapStringForOptions := "map[string]string{"
for _, k := range keysForOptions {
mapStringForOptions += fmt.Sprintf("%v: %v,", k, this.Options[k])
}
mapStringForOptions += "}"
s := strings.Join([]string{`&Container_Runtime{`,
`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
`Options:` + mapStringForOptions + `,`,
`}`,
}, "")
return s
}
func (this *GetContainerRequest) String() string { func (this *GetContainerRequest) String() string {
if this == nil { if this == nil {
return "nil" return "nil"
@ -1223,7 +1321,7 @@ func (m *Container) Unmarshal(dAtA []byte) error {
if wireType != 2 { if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Runtime", wireType) return fmt.Errorf("proto: wrong wireType = %d for field Runtime", wireType)
} }
var stringLen uint64 var msglen int
for shift := uint(0); ; shift += 7 { for shift := uint(0); ; shift += 7 {
if shift >= 64 { if shift >= 64 {
return ErrIntOverflowContainers return ErrIntOverflowContainers
@ -1233,22 +1331,26 @@ func (m *Container) Unmarshal(dAtA []byte) error {
} }
b := dAtA[iNdEx] b := dAtA[iNdEx]
iNdEx++ iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift msglen |= (int(b) & 0x7F) << shift
if b < 0x80 { if b < 0x80 {
break break
} }
} }
intStringLen := int(stringLen) if msglen < 0 {
if intStringLen < 0 {
return ErrInvalidLengthContainers return ErrInvalidLengthContainers
} }
postIndex := iNdEx + intStringLen postIndex := iNdEx + msglen
if postIndex > l { if postIndex > l {
return io.ErrUnexpectedEOF return io.ErrUnexpectedEOF
} }
m.Runtime = string(dAtA[iNdEx:postIndex]) if m.Runtime == nil {
m.Runtime = &Container_Runtime{}
}
if err := m.Runtime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex iNdEx = postIndex
case 6: case 5:
if wireType != 2 { if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
} }
@ -1281,7 +1383,7 @@ func (m *Container) Unmarshal(dAtA []byte) error {
return err return err
} }
iNdEx = postIndex iNdEx = postIndex
case 7: case 6:
if wireType != 2 { if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field RootFS", wireType) return fmt.Errorf("proto: wrong wireType = %d for field RootFS", wireType)
} }
@ -1310,7 +1412,7 @@ func (m *Container) Unmarshal(dAtA []byte) error {
} }
m.RootFS = string(dAtA[iNdEx:postIndex]) m.RootFS = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex iNdEx = postIndex
case 8: case 7:
if wireType != 2 { if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType) return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
} }
@ -1340,7 +1442,7 @@ func (m *Container) Unmarshal(dAtA []byte) error {
return err return err
} }
iNdEx = postIndex iNdEx = postIndex
case 9: case 8:
if wireType != 2 { if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAt", wireType) return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAt", wireType)
} }
@ -1391,6 +1493,201 @@ func (m *Container) Unmarshal(dAtA []byte) error {
} }
return nil return nil
} }
func (m *Container_Runtime) 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 ErrIntOverflowContainers
}
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: Runtime: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Runtime: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowContainers
}
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 ErrInvalidLengthContainers
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Name = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowContainers
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthContainers
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
var keykey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowContainers
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
keykey |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
var stringLenmapkey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowContainers
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLenmapkey |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLenmapkey := int(stringLenmapkey)
if intStringLenmapkey < 0 {
return ErrInvalidLengthContainers
}
postStringIndexmapkey := iNdEx + intStringLenmapkey
if postStringIndexmapkey > l {
return io.ErrUnexpectedEOF
}
mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
iNdEx = postStringIndexmapkey
if m.Options == nil {
m.Options = make(map[string]string)
}
if iNdEx < postIndex {
var valuekey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowContainers
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
valuekey |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
var stringLenmapvalue uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowContainers
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLenmapvalue |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLenmapvalue := int(stringLenmapvalue)
if intStringLenmapvalue < 0 {
return ErrInvalidLengthContainers
}
postStringIndexmapvalue := iNdEx + intStringLenmapvalue
if postStringIndexmapvalue > l {
return io.ErrUnexpectedEOF
}
mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
iNdEx = postStringIndexmapvalue
m.Options[mapkey] = mapvalue
} else {
var mapvalue string
m.Options[mapkey] = mapvalue
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipContainers(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthContainers
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *GetContainerRequest) Unmarshal(dAtA []byte) error { func (m *GetContainerRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA) l := len(dAtA)
iNdEx := 0 iNdEx := 0
@ -2252,48 +2549,52 @@ func init() {
} }
var fileDescriptorContainers = []byte{ var fileDescriptorContainers = []byte{
// 680 bytes of a gzipped FileDescriptorProto // 745 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0xcd, 0x6e, 0xd3, 0x40, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0xcd, 0x6e, 0xda, 0x4a,
0x10, 0xae, 0x93, 0xe0, 0x36, 0x13, 0x21, 0xa1, 0x25, 0x04, 0x63, 0xa4, 0x24, 0x32, 0x3f, 0xca, 0x14, 0x8e, 0x81, 0x98, 0x70, 0xb8, 0x8b, 0xab, 0xb9, 0x5c, 0xae, 0xaf, 0x2b, 0x01, 0x65, 0xc5,
0x05, 0x1b, 0xc2, 0x85, 0x9f, 0x0a, 0xa9, 0xe9, 0x9f, 0x2a, 0x15, 0x0e, 0x6e, 0xa1, 0xdc, 0x2a, 0xa2, 0x35, 0x2d, 0xad, 0xda, 0x24, 0x5d, 0x41, 0xfe, 0x14, 0x29, 0x6d, 0xa3, 0x69, 0xbb, 0xca,
0x27, 0xde, 0x04, 0xab, 0x8e, 0xd7, 0x78, 0x37, 0x95, 0x72, 0xe3, 0x11, 0x90, 0x78, 0x05, 0x8e, 0x22, 0x32, 0x30, 0x10, 0x17, 0xe3, 0x71, 0x3d, 0x03, 0x12, 0xea, 0xa2, 0x7d, 0x84, 0xbe, 0x45,
0x3c, 0x48, 0x8f, 0x1c, 0x39, 0x15, 0x9a, 0x27, 0x41, 0xbb, 0x5e, 0xd7, 0xa9, 0xed, 0x50, 0x10, 0xde, 0xa0, 0xcf, 0x90, 0x65, 0x97, 0x5d, 0xa5, 0x09, 0x4f, 0x52, 0x79, 0x3c, 0x8e, 0x29, 0x38,
0xbd, 0xcd, 0x78, 0xbe, 0xf9, 0x32, 0xf3, 0xcd, 0x67, 0x07, 0x76, 0x46, 0x1e, 0xfb, 0x30, 0xe9, 0xaa, 0x41, 0xcd, 0xee, 0x4c, 0xe6, 0x7c, 0xdf, 0xf9, 0xe6, 0x3b, 0xe7, 0x38, 0xc0, 0x61, 0xdf,
0x9b, 0x03, 0x32, 0xb6, 0x06, 0x24, 0x60, 0x8e, 0x17, 0xe0, 0xc8, 0x9d, 0x0f, 0x9d, 0xd0, 0xb3, 0xe2, 0x67, 0xa3, 0xb6, 0xd1, 0xa1, 0xc3, 0x7a, 0x87, 0x3a, 0xdc, 0xb4, 0x1c, 0xe2, 0x75, 0x67,
0x28, 0x8e, 0x8e, 0xbd, 0x01, 0xa6, 0xe9, 0xf3, 0xf9, 0xd0, 0x0c, 0x23, 0xc2, 0x08, 0xba, 0x9e, 0x43, 0xd3, 0xb5, 0xea, 0x8c, 0x78, 0x63, 0xab, 0x43, 0x58, 0xf4, 0xf7, 0xd9, 0xd0, 0x70, 0x3d,
0x36, 0x99, 0xc7, 0x4f, 0xf4, 0xfa, 0x88, 0x8c, 0x88, 0xa8, 0x58, 0x3c, 0x8a, 0x41, 0xfa, 0x9d, 0xca, 0x29, 0xba, 0x1f, 0x81, 0x8c, 0x10, 0x60, 0xcc, 0x64, 0x8d, 0x1f, 0xeb, 0x85, 0x3e, 0xed,
0x11, 0x21, 0x23, 0x1f, 0x5b, 0x22, 0xeb, 0x4f, 0x86, 0x96, 0x13, 0x4c, 0x65, 0xe9, 0x6e, 0xb6, 0x53, 0x91, 0x5d, 0xf7, 0xa3, 0x00, 0xa8, 0xff, 0xdf, 0xa7, 0xb4, 0x6f, 0x93, 0xba, 0x38, 0xb5,
0x84, 0xc7, 0x21, 0x4b, 0x8a, 0xed, 0x6c, 0x71, 0xe8, 0x61, 0xdf, 0x3d, 0x1c, 0x3b, 0xf4, 0x48, 0x47, 0xbd, 0xba, 0xe9, 0x4c, 0xe4, 0xd5, 0xbd, 0xf9, 0x2b, 0x32, 0x74, 0x79, 0x78, 0x59, 0x99,
0x22, 0x5a, 0x59, 0x04, 0xf3, 0xc6, 0x98, 0x32, 0x67, 0x1c, 0x4a, 0xc0, 0xd6, 0x5f, 0xad, 0xca, 0xbf, 0xec, 0x59, 0xc4, 0xee, 0x9e, 0x0e, 0x4d, 0x36, 0x90, 0x19, 0xe5, 0xf9, 0x0c, 0x6e, 0x0d,
0xa6, 0x21, 0xa6, 0x96, 0x8b, 0xe9, 0x20, 0xf2, 0x42, 0x46, 0xa2, 0xb9, 0x30, 0xe6, 0x31, 0xbe, 0x09, 0xe3, 0xe6, 0xd0, 0x95, 0x09, 0xfb, 0x89, 0x9e, 0xcf, 0x27, 0x2e, 0x61, 0xf5, 0x2e, 0x61,
0x96, 0xa1, 0xba, 0x9e, 0x34, 0xa1, 0x06, 0x94, 0x3c, 0x57, 0x53, 0xda, 0x4a, 0xa7, 0xda, 0x53, 0x1d, 0xcf, 0x72, 0x39, 0xf5, 0x66, 0xc2, 0x80, 0xa7, 0x7a, 0xbe, 0x0e, 0xb9, 0x9d, 0x10, 0x84,
0x67, 0xa7, 0xad, 0xd2, 0xce, 0x86, 0x5d, 0xf2, 0x5c, 0xb4, 0x0a, 0xaa, 0xef, 0xf4, 0xb1, 0x4f, 0x8a, 0x90, 0xb2, 0xba, 0x9a, 0x52, 0x51, 0x6a, 0xb9, 0x96, 0x3a, 0xbd, 0x2c, 0xa7, 0x0e, 0x77,
0xb5, 0x52, 0xbb, 0xdc, 0xa9, 0x75, 0xef, 0x9b, 0x17, 0xe4, 0x31, 0xcf, 0x19, 0xcc, 0x5d, 0x01, 0x71, 0xca, 0xea, 0xa2, 0x63, 0x50, 0x6d, 0xb3, 0x4d, 0x6c, 0xa6, 0xa5, 0x2a, 0xe9, 0x5a, 0xbe,
0xdb, 0x0c, 0x58, 0x34, 0xb5, 0x65, 0x0f, 0xaa, 0xc3, 0x35, 0x6f, 0xec, 0x8c, 0xb0, 0x56, 0xe6, 0xb1, 0x69, 0xfc, 0xd6, 0x32, 0xe3, 0x86, 0xd5, 0x38, 0x12, 0xd0, 0x3d, 0x87, 0x7b, 0x13, 0x2c,
0xc4, 0x76, 0x9c, 0x20, 0x0d, 0x96, 0xa3, 0x49, 0xc0, 0xf7, 0xd2, 0x2a, 0xe2, 0x79, 0x92, 0xa2, 0x79, 0x50, 0x01, 0xd6, 0xad, 0xa1, 0xd9, 0x27, 0x5a, 0xda, 0x2f, 0x86, 0x83, 0x03, 0x7a, 0x05,
0x0e, 0x54, 0x68, 0x88, 0x07, 0x9a, 0xda, 0x56, 0x3a, 0xb5, 0x6e, 0xdd, 0x8c, 0xb5, 0x30, 0x13, 0x59, 0x6f, 0xe4, 0xf8, 0x6f, 0xd5, 0x32, 0x15, 0xa5, 0x96, 0x6f, 0x3c, 0x5d, 0xaa, 0x10, 0x0e,
0x2d, 0xcc, 0xb5, 0x60, 0x6a, 0x0b, 0x04, 0x32, 0x40, 0x8d, 0x08, 0x61, 0x43, 0xaa, 0x2d, 0x8b, 0xb0, 0x38, 0x24, 0x41, 0x35, 0xc8, 0x30, 0x97, 0x74, 0xb4, 0x75, 0x41, 0x56, 0x30, 0x02, 0x57,
0x99, 0x61, 0x76, 0xda, 0x52, 0x6d, 0x42, 0xd8, 0xd6, 0x9e, 0x2d, 0x2b, 0x68, 0x1d, 0x60, 0x10, 0x8d, 0xd0, 0x55, 0xa3, 0xe9, 0x4c, 0xb0, 0xc8, 0x40, 0x55, 0x50, 0x3d, 0x4a, 0x79, 0x8f, 0x69,
0x61, 0x87, 0x61, 0xf7, 0xd0, 0x61, 0xda, 0x8a, 0xe0, 0xd4, 0x73, 0x9c, 0xfb, 0x89, 0xbe, 0xbd, 0xaa, 0x78, 0x3d, 0x4c, 0x2f, 0xcb, 0x2a, 0xa6, 0x94, 0xef, 0xbf, 0xc1, 0xf2, 0x06, 0xed, 0x00,
0x95, 0x93, 0xd3, 0xd6, 0xd2, 0xe7, 0x9f, 0x2d, 0xc5, 0xae, 0xca, 0xbe, 0x35, 0xc6, 0x49, 0x26, 0x74, 0x3c, 0x62, 0x72, 0xd2, 0x3d, 0x35, 0xb9, 0x96, 0x15, 0x9c, 0xfa, 0x02, 0xe7, 0xdb, 0xb0,
0xa1, 0x9b, 0x90, 0x54, 0xff, 0x85, 0x44, 0xf6, 0xad, 0x31, 0xfd, 0x39, 0xd4, 0xe6, 0xe4, 0x41, 0x53, 0xad, 0x8d, 0x8b, 0xcb, 0xf2, 0xda, 0x97, 0x1f, 0x65, 0x05, 0xe7, 0x24, 0xae, 0xc9, 0x7d,
0x37, 0xa0, 0x7c, 0x84, 0xa7, 0xb1, 0xda, 0x36, 0x0f, 0xb9, 0x50, 0xc7, 0x8e, 0x3f, 0xc1, 0x5a, 0x92, 0x91, 0xdb, 0x0d, 0x49, 0x36, 0x96, 0x21, 0x91, 0xb8, 0x26, 0xd7, 0xb7, 0x20, 0x3f, 0x63,
0x29, 0x16, 0x4a, 0x24, 0x2f, 0x4a, 0xcf, 0x14, 0xe3, 0x11, 0xdc, 0xdc, 0xc6, 0xec, 0x5c, 0x66, 0x2a, 0xfa, 0x1b, 0xd2, 0x03, 0x32, 0x09, 0xfa, 0x86, 0xfd, 0xd0, 0xb7, 0x77, 0x6c, 0xda, 0x23,
0x1b, 0x7f, 0x9c, 0x60, 0xca, 0x16, 0xdd, 0xcb, 0xd8, 0x87, 0xfa, 0x45, 0x38, 0x0d, 0x49, 0x40, 0xa2, 0xa5, 0x02, 0x7b, 0xc5, 0x61, 0x3b, 0xb5, 0xa9, 0xe8, 0x5f, 0x15, 0xc8, 0x4a, 0x9f, 0x10,
0x31, 0x5a, 0x85, 0xea, 0xf9, 0xe1, 0x44, 0x5b, 0xad, 0xab, 0x2d, 0x3a, 0x65, 0xaf, 0xc2, 0x77, 0x82, 0x8c, 0x63, 0x0e, 0x89, 0x04, 0x8a, 0x18, 0x9d, 0x40, 0x96, 0xba, 0xdc, 0xa2, 0x4e, 0xd8,
0xb0, 0xd3, 0x06, 0xc3, 0x82, 0x5b, 0xbb, 0x1e, 0x4d, 0x69, 0x69, 0x3a, 0x86, 0x3a, 0xf4, 0x7c, 0xeb, 0xe6, 0x2a, 0x2d, 0x30, 0x5e, 0x07, 0x1c, 0x41, 0xd3, 0x43, 0x46, 0x7d, 0x1b, 0xfe, 0x9a,
0x26, 0x39, 0xab, 0xb6, 0xcc, 0x8c, 0xf7, 0xd0, 0xc8, 0x36, 0xc8, 0x41, 0x5e, 0x01, 0xa4, 0xaf, 0xbd, 0x58, 0x46, 0x78, 0xf5, 0x21, 0xfc, 0x73, 0x40, 0xf8, 0x4d, 0x25, 0x4c, 0x3e, 0x8c, 0x08,
0x9c, 0xa6, 0x08, 0x53, 0x5d, 0x36, 0xc9, 0x5c, 0x87, 0xf1, 0x0e, 0x1a, 0xeb, 0xe2, 0x38, 0x39, 0xe3, 0xb7, 0x8d, 0x6c, 0xf5, 0x0c, 0x0a, 0xbf, 0xa6, 0x33, 0x97, 0x3a, 0x8c, 0xa0, 0x63, 0xc8,
0x49, 0xfe, 0x6f, 0xc5, 0x03, 0xb8, 0x9d, 0xe3, 0xbd, 0x12, 0xed, 0xbe, 0x28, 0xd0, 0x78, 0x2b, 0xdd, 0x68, 0x17, 0xb0, 0x7c, 0xe3, 0xc1, 0x32, 0x2f, 0x6c, 0x65, 0xfc, 0x86, 0xe0, 0x88, 0xa4,
0x9c, 0x70, 0xb5, 0x13, 0xa3, 0x97, 0x50, 0x8b, 0x1d, 0x26, 0x3e, 0x1f, 0xc2, 0x39, 0x45, 0xd6, 0x5a, 0x87, 0x7f, 0x8f, 0x2c, 0x16, 0x95, 0x62, 0x91, 0x34, 0xb5, 0x67, 0xd9, 0x5c, 0xd6, 0xc9,
0xdc, 0xe2, 0x5f, 0x98, 0xd7, 0x0e, 0x3d, 0xb2, 0xa5, 0x91, 0x79, 0xcc, 0xd7, 0xcd, 0x0d, 0x75, 0x61, 0x79, 0xaa, 0xda, 0x50, 0x9c, 0x07, 0x48, 0x71, 0x18, 0x20, 0x2a, 0xab, 0x29, 0xc2, 0xff,
0x25, 0xeb, 0x3e, 0x86, 0xc6, 0x06, 0xf6, 0x71, 0xc1, 0xb6, 0x0b, 0x2c, 0xdb, 0xfd, 0x56, 0x06, 0x55, 0xd4, 0xcd, 0xb0, 0x54, 0xdf, 0x43, 0x71, 0x47, 0x4c, 0xdf, 0x82, 0x75, 0x7f, 0xde, 0x8a,
0x48, 0x8d, 0x82, 0xde, 0x40, 0x79, 0x1b, 0x33, 0x64, 0x64, 0x7e, 0xb2, 0xe0, 0x25, 0xd0, 0xef, 0x01, 0xfc, 0xb7, 0x50, 0xeb, 0xce, 0x7c, 0x3f, 0x57, 0xa0, 0xf8, 0x4e, 0xac, 0xc4, 0xdd, 0xbf,
0xfd, 0x11, 0x23, 0xd7, 0xd9, 0x83, 0x0a, 0xb7, 0x22, 0xca, 0x7e, 0xb9, 0x0a, 0x0d, 0xad, 0x3f, 0x0c, 0xbd, 0x80, 0x7c, 0xb0, 0x7e, 0xe2, 0x2b, 0x2d, 0xa6, 0x33, 0x6e, 0x6f, 0xf7, 0xfd, 0x0f,
0xb8, 0x04, 0x25, 0x49, 0x0f, 0x40, 0x8d, 0xdd, 0x82, 0xb2, 0x0d, 0xc5, 0xe6, 0xd4, 0x1f, 0x5e, 0xf9, 0x4b, 0x93, 0x0d, 0xb0, 0xdc, 0x72, 0x3f, 0xf6, 0x6d, 0x59, 0x10, 0x7a, 0x67, 0xb6, 0x3c,
0x06, 0x4b, 0x89, 0xe3, 0xbb, 0xe4, 0x88, 0x8b, 0x3d, 0x94, 0x23, 0x5e, 0x74, 0xd5, 0x6d, 0x50, 0x82, 0xe2, 0x2e, 0xb1, 0x49, 0x8c, 0x2b, 0xb7, 0xac, 0x4a, 0xe3, 0x2a, 0x03, 0x10, 0x0d, 0x23,
0xe3, 0xbb, 0xe4, 0x88, 0x8b, 0xcf, 0xa5, 0x37, 0x72, 0x4e, 0xda, 0xe4, 0x7f, 0x64, 0x3d, 0xed, 0x1a, 0x43, 0xfa, 0x80, 0x70, 0xf4, 0x2c, 0x81, 0x8c, 0x98, 0x85, 0xd4, 0x9f, 0x2f, 0x8d, 0x93,
0xe4, 0xac, 0xb9, 0xf4, 0xe3, 0xac, 0xb9, 0xf4, 0x69, 0xd6, 0x54, 0x4e, 0x66, 0x4d, 0xe5, 0xfb, 0x56, 0x7c, 0x84, 0x8c, 0xbf, 0x16, 0x28, 0xc9, 0x3f, 0x97, 0xd8, 0x85, 0xd3, 0xb7, 0x56, 0x40,
0xac, 0xa9, 0xfc, 0x9a, 0x35, 0x95, 0xbe, 0x2a, 0x90, 0x4f, 0x7f, 0x07, 0x00, 0x00, 0xff, 0xff, 0xca, 0xe2, 0x9f, 0x40, 0x0d, 0x26, 0x17, 0x25, 0x21, 0x89, 0x5f, 0x28, 0x7d, 0x7b, 0x15, 0x68,
0xc1, 0x18, 0xeb, 0x02, 0x8d, 0x07, 0x00, 0x00, 0x24, 0x20, 0x98, 0x91, 0x44, 0x02, 0xe2, 0xe7, 0x3e, 0x91, 0x80, 0xdb, 0x26, 0xf1, 0x04, 0xd4,
0x60, 0x6e, 0x12, 0x09, 0x88, 0x1f, 0x31, 0xbd, 0xb8, 0xb0, 0x11, 0x7b, 0xfe, 0xef, 0x9e, 0x96,
0x76, 0x71, 0x5d, 0x5a, 0xfb, 0x7e, 0x5d, 0x5a, 0xfb, 0x3c, 0x2d, 0x29, 0x17, 0xd3, 0x92, 0xf2,
0x6d, 0x5a, 0x52, 0xae, 0xa6, 0x25, 0xa5, 0xad, 0x8a, 0xcc, 0x27, 0x3f, 0x03, 0x00, 0x00, 0xff,
0xff, 0xcd, 0xae, 0xd0, 0xb5, 0xd0, 0x09, 0x00, 0x00,
} }

21
api/services/containers/containers.proto
View File

@ -1,6 +1,6 @@
syntax = "proto3"; syntax = "proto3";
package containerd.v1; package containerd.services.containers.v1;
import "gogoproto/gogo.proto"; import "gogoproto/gogo.proto";
import "google/protobuf/any.proto"; import "google/protobuf/any.proto";
@ -51,11 +51,17 @@ message Container {
// If this field is updated, the spec and rootfs needed to updated, as well. // If this field is updated, the spec and rootfs needed to updated, as well.
string image = 3; string image = 3;
message Runtime {
// Name is the name of the runtime.
string name = 1;
// Options specify additional runtime initialization options.
map<string, string> options = 2;
}
// Runtime specifies which runtime to use for executing this container. // Runtime specifies which runtime to use for executing this container.
string runtime = 4; Runtime runtime = 4;
// Spec to be used when creating the container. This is runtime specific. // Spec to be used when creating the container. This is runtime specific.
google.protobuf.Any spec = 6; google.protobuf.Any spec = 5;
// RootFS specifies the snapshot key to use for the container's root // RootFS specifies the snapshot key to use for the container's root
// filesystem. When starting a task from this container, a caller should // filesystem. When starting a task from this container, a caller should
@ -65,10 +71,13 @@ message Container {
// Snapshots referenced in this field will not be garbage collected. // Snapshots referenced in this field will not be garbage collected.
// //
// This field may be updated. // This field may be updated.
string rootfs = 7 [(gogoproto.customname) = "RootFS"]; string rootfs = 6 [(gogoproto.customname) = "RootFS"];
google.protobuf.Timestamp created_at = 8 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; // CreatedAt is the time the container was first created.
google.protobuf.Timestamp updated_at = 9 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; google.protobuf.Timestamp created_at = 7 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
// UpdatedAt is the last time the container was mutated.
google.protobuf.Timestamp updated_at = 8 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
} }
message GetContainerRequest { message GetContainerRequest {

585
api/services/content/content.pb.go
View File

File diff suppressed because it is too large Load Diff

30
api/services/content/content.proto
View File

@ -1,6 +1,6 @@
syntax = "proto3"; syntax = "proto3";
package containerd.v1; package containerd.services.content.v1;
import "gogoproto/gogo.proto"; import "gogoproto/gogo.proto";
import "google/protobuf/timestamp.proto"; import "google/protobuf/timestamp.proto";
@ -28,7 +28,7 @@ service Content {
// Read allows one to read an object based on the offset into the content. // Read allows one to read an object based on the offset into the content.
// //
// The requested data may be returned in one or more messages. // The requested data may be returned in one or more messages.
rpc Read(ReadRequest) returns (stream ReadResponse); rpc Read(ReadContentRequest) returns (stream ReadContentResponse);
// Status returns the status of ongoing object ingestions, started via // Status returns the status of ongoing object ingestions, started via
// Write. // Write.
@ -54,7 +54,7 @@ service Content {
// //
// When completed, the commit flag should be set to true. If expected size // When completed, the commit flag should be set to true. If expected size
// or digest is set, the content will be validated against those values. // or digest is set, the content will be validated against those values.
rpc Write(stream WriteRequest) returns (stream WriteResponse); rpc Write(stream WriteContentRequest) returns (stream WriteContentResponse);
// Abort cancels the ongoing write named in the request. Any resources // Abort cancels the ongoing write named in the request. Any resources
// associated with the write will be collected. // associated with the write will be collected.
@ -91,9 +91,9 @@ message DeleteContentRequest {
string digest = 1 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false]; string digest = 1 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false];
} }
// ReadRequest defines the fields that make up a request to read a portion of // ReadContentRequest defines the fields that make up a request to read a portion of
// data from a stored object. // data from a stored object.
message ReadRequest { message ReadContentRequest {
// Digest is the hash identity to read. // Digest is the hash identity to read.
string digest = 1 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false]; string digest = 1 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false];
@ -107,16 +107,12 @@ message ReadRequest {
int64 size = 3; int64 size = 3;
} }
// ReadResponse carries byte data for a read request. // ReadContentResponse carries byte data for a read request.
message ReadResponse { message ReadContentResponse {
int64 offset = 1; // offset of the returned data int64 offset = 1; // offset of the returned data
bytes data = 2; // actual data bytes data = 2; // actual data
} }
message StatusRequest {
string regexp = 1;
}
message Status { message Status {
google.protobuf.Timestamp started_at = 1 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; google.protobuf.Timestamp started_at = 1 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
google.protobuf.Timestamp updated_at = 2 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; google.protobuf.Timestamp updated_at = 2 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
@ -126,6 +122,10 @@ message Status {
string expected = 6 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false]; string expected = 6 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false];
} }
message StatusRequest {
string filter = 1;
}
message StatusResponse { message StatusResponse {
repeated Status statuses = 1 [(gogoproto.nullable) = false]; repeated Status statuses = 1 [(gogoproto.nullable) = false];
} }
@ -157,8 +157,8 @@ enum WriteAction {
COMMIT = 2 [(gogoproto.enumvalue_customname) = "WriteActionCommit"]; COMMIT = 2 [(gogoproto.enumvalue_customname) = "WriteActionCommit"];
} }
// WriteRequest writes data to the request ref at offset. // WriteContentRequest writes data to the request ref at offset.
message WriteRequest { message WriteContentRequest {
// Action sets the behavior of the write. // Action sets the behavior of the write.
// //
// When this is a write and the ref is not yet allocated, the ref will be // When this is a write and the ref is not yet allocated, the ref will be
@ -215,8 +215,8 @@ message WriteRequest {
bytes data = 6; bytes data = 6;
} }
// WriteResponse is returned on the culmination of a write call. // WriteContentResponse is returned on the culmination of a write call.
message WriteResponse { message WriteContentResponse {
// Action contains the action for the final message of the stream. A writer // Action contains the action for the final message of the stream. A writer
// should confirm that they match the intended result. // should confirm that they match the intended result.
WriteAction action = 1; WriteAction action = 1;

73
api/services/diff/diff.pb.go
View File

@ -96,10 +96,10 @@ func (*DiffResponse) ProtoMessage() {}
func (*DiffResponse) Descriptor() ([]byte, []int) { return fileDescriptorDiff, []int{3} } func (*DiffResponse) Descriptor() ([]byte, []int) { return fileDescriptorDiff, []int{3} }
func init() { func init() {
proto.RegisterType((*ApplyRequest)(nil), "containerd.v1.ApplyRequest") proto.RegisterType((*ApplyRequest)(nil), "containerd.services.diff.v1.ApplyRequest")
proto.RegisterType((*ApplyResponse)(nil), "containerd.v1.ApplyResponse") proto.RegisterType((*ApplyResponse)(nil), "containerd.services.diff.v1.ApplyResponse")
proto.RegisterType((*DiffRequest)(nil), "containerd.v1.DiffRequest") proto.RegisterType((*DiffRequest)(nil), "containerd.services.diff.v1.DiffRequest")
proto.RegisterType((*DiffResponse)(nil), "containerd.v1.DiffResponse") proto.RegisterType((*DiffResponse)(nil), "containerd.services.diff.v1.DiffResponse")
} }
// Reference imports to suppress errors if they are not otherwise used. // Reference imports to suppress errors if they are not otherwise used.
@ -132,7 +132,7 @@ func NewDiffClient(cc *grpc.ClientConn) DiffClient {
func (c *diffClient) Apply(ctx context.Context, in *ApplyRequest, opts ...grpc.CallOption) (*ApplyResponse, error) { func (c *diffClient) Apply(ctx context.Context, in *ApplyRequest, opts ...grpc.CallOption) (*ApplyResponse, error) {
out := new(ApplyResponse) out := new(ApplyResponse)
err := grpc.Invoke(ctx, "/containerd.v1.Diff/Apply", in, out, c.cc, opts...) err := grpc.Invoke(ctx, "/containerd.services.diff.v1.Diff/Apply", in, out, c.cc, opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -141,7 +141,7 @@ func (c *diffClient) Apply(ctx context.Context, in *ApplyRequest, opts ...grpc.C
func (c *diffClient) Diff(ctx context.Context, in *DiffRequest, opts ...grpc.CallOption) (*DiffResponse, error) { func (c *diffClient) Diff(ctx context.Context, in *DiffRequest, opts ...grpc.CallOption) (*DiffResponse, error) {
out := new(DiffResponse) out := new(DiffResponse)
err := grpc.Invoke(ctx, "/containerd.v1.Diff/Diff", in, out, c.cc, opts...) err := grpc.Invoke(ctx, "/containerd.services.diff.v1.Diff/Diff", in, out, c.cc, opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -174,7 +174,7 @@ func _Diff_Apply_Handler(srv interface{}, ctx context.Context, dec func(interfac
} }
info := &grpc.UnaryServerInfo{ info := &grpc.UnaryServerInfo{
Server: srv, Server: srv,
FullMethod: "/containerd.v1.Diff/Apply", FullMethod: "/containerd.services.diff.v1.Diff/Apply",
} }
handler := func(ctx context.Context, req interface{}) (interface{}, error) { handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DiffServer).Apply(ctx, req.(*ApplyRequest)) return srv.(DiffServer).Apply(ctx, req.(*ApplyRequest))
@ -192,7 +192,7 @@ func _Diff_Diff_Handler(srv interface{}, ctx context.Context, dec func(interface
} }
info := &grpc.UnaryServerInfo{ info := &grpc.UnaryServerInfo{
Server: srv, Server: srv,
FullMethod: "/containerd.v1.Diff/Diff", FullMethod: "/containerd.services.diff.v1.Diff/Diff",
} }
handler := func(ctx context.Context, req interface{}) (interface{}, error) { handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DiffServer).Diff(ctx, req.(*DiffRequest)) return srv.(DiffServer).Diff(ctx, req.(*DiffRequest))
@ -201,7 +201,7 @@ func _Diff_Diff_Handler(srv interface{}, ctx context.Context, dec func(interface
} }
var _Diff_serviceDesc = grpc.ServiceDesc{ var _Diff_serviceDesc = grpc.ServiceDesc{
ServiceName: "containerd.v1.Diff", ServiceName: "containerd.services.diff.v1.Diff",
HandlerType: (*DiffServer)(nil), HandlerType: (*DiffServer)(nil),
Methods: []grpc.MethodDesc{ Methods: []grpc.MethodDesc{
{ {
@ -1081,31 +1081,32 @@ func init() {
} }
var fileDescriptorDiff = []byte{ var fileDescriptorDiff = []byte{
// 407 bytes of a gzipped FileDescriptorProto // 420 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x52, 0x41, 0xcf, 0x93, 0x40, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0x31, 0x8f, 0x94, 0x40,
0x10, 0xfd, 0x56, 0xda, 0xcf, 0x74, 0xdb, 0x26, 0x66, 0xe3, 0x81, 0x50, 0xa5, 0x0d, 0xa7, 0x9e, 0x14, 0xc7, 0x6f, 0x64, 0xf7, 0xcc, 0xcd, 0x9e, 0x89, 0x99, 0x58, 0x10, 0x2e, 0x72, 0x1b, 0x2a,
0x40, 0xe9, 0xc9, 0x44, 0x63, 0xac, 0x8d, 0x07, 0x13, 0x2f, 0xc4, 0xbb, 0xa1, 0x30, 0xd0, 0x4d, 0xce, 0x62, 0xf0, 0xb8, 0xca, 0x44, 0x0b, 0xf5, 0x62, 0x61, 0x62, 0x43, 0xec, 0x4c, 0x34, 0x2c,
0x80, 0x5d, 0xd9, 0xa5, 0x86, 0x9b, 0x77, 0xff, 0x84, 0x3f, 0xa7, 0x47, 0x8f, 0x1e, 0x2d, 0xbf, 0x3c, 0xb8, 0x49, 0x80, 0x19, 0x99, 0x61, 0x0d, 0x9d, 0x1f, 0xc5, 0xef, 0x62, 0x73, 0xa5, 0xa5,
0xc4, 0xb0, 0x6c, 0x15, 0x9b, 0x26, 0xb6, 0x97, 0xcd, 0xb0, 0xef, 0xcd, 0x9b, 0x37, 0x8f, 0xc5, 0xa5, 0xcb, 0x27, 0x31, 0x0c, 0x83, 0x12, 0x63, 0xf6, 0xd8, 0x66, 0xf2, 0x98, 0xf7, 0x7b, 0xef,
0xaf, 0x52, 0x2a, 0x77, 0xd5, 0xd6, 0x8d, 0x58, 0xee, 0x45, 0xac, 0x90, 0x21, 0x2d, 0xa0, 0x8c, 0xfd, 0xdf, 0x9f, 0xc1, 0x2f, 0x72, 0xa6, 0x6e, 0x9a, 0x0d, 0x4d, 0x78, 0x19, 0x24, 0xbc, 0x52,
0xfb, 0x65, 0xc8, 0xa9, 0x27, 0xa0, 0xdc, 0xd3, 0x08, 0x84, 0x17, 0xd3, 0x24, 0x51, 0x87, 0xcb, 0x31, 0xab, 0xa0, 0x4e, 0xa7, 0x61, 0x2c, 0x58, 0x20, 0xa1, 0xde, 0xb2, 0x04, 0x64, 0x90, 0xb2,
0x4b, 0x26, 0x19, 0x99, 0xfe, 0x25, 0xba, 0xfb, 0xe7, 0xd6, 0xe3, 0x94, 0xa5, 0x4c, 0x21, 0x5e, 0x2c, 0xd3, 0x07, 0x15, 0x35, 0x57, 0x9c, 0x9c, 0xfd, 0x05, 0xe9, 0x08, 0x51, 0x9d, 0xdf, 0x5e,
0x5b, 0x75, 0x24, 0x6b, 0x96, 0x32, 0x96, 0x66, 0xe0, 0xa9, 0xaf, 0x6d, 0x95, 0x78, 0x90, 0x73, 0x3a, 0x8f, 0x72, 0x9e, 0x73, 0xcd, 0x05, 0x7d, 0x34, 0x94, 0x38, 0x67, 0x39, 0xe7, 0x79, 0x01,
0x59, 0x6b, 0x70, 0x7e, 0x0e, 0x4a, 0x9a, 0x83, 0x90, 0x61, 0xce, 0x35, 0xe1, 0xe5, 0x55, 0x0e, 0x81, 0xfe, 0xda, 0x34, 0x59, 0x00, 0xa5, 0x50, 0xad, 0x49, 0x9e, 0xff, 0x9b, 0x54, 0xac, 0x04,
0x65, 0xcd, 0x41, 0x78, 0x39, 0xab, 0x0a, 0xd9, 0x9d, 0xba, 0xfb, 0xdd, 0x0d, 0xdd, 0x31, 0x88, 0xa9, 0xe2, 0x52, 0x18, 0xe0, 0xf9, 0x2c, 0xbd, 0xaa, 0x15, 0x20, 0x83, 0x92, 0x37, 0x95, 0x1a,
0xa8, 0xa4, 0x5c, 0xb2, 0xb2, 0x57, 0x76, 0x3a, 0xce, 0x17, 0x3c, 0x79, 0xc3, 0x79, 0x56, 0x07, 0x4e, 0x53, 0xfd, 0xe6, 0x80, 0xea, 0x14, 0x64, 0x52, 0x33, 0xa1, 0x78, 0x3d, 0x09, 0x87, 0x3e,
0xf0, 0xb9, 0x02, 0x21, 0xc9, 0x0a, 0x0f, 0xda, 0x18, 0x4c, 0xb4, 0x40, 0xcb, 0xb1, 0x3f, 0x77, 0xde, 0x17, 0x7c, 0xfa, 0x52, 0x88, 0xa2, 0x8d, 0xe0, 0x73, 0x03, 0x52, 0x91, 0x2b, 0xbc, 0xe8,
0xff, 0xc9, 0xc1, 0x55, 0x7a, 0xee, 0xe6, 0x8f, 0x48, 0xa0, 0xc8, 0xc4, 0xc7, 0xf7, 0xca, 0x9b, 0x97, 0xb6, 0xd1, 0x1a, 0xf9, 0xab, 0xf0, 0x9c, 0x4e, 0x5c, 0xd9, 0x5e, 0x52, 0xdd, 0x8f, 0x5e,
0x30, 0x1f, 0x2c, 0x8c, 0xe5, 0xd8, 0xb7, 0x2e, 0xb6, 0x7d, 0x68, 0x29, 0x81, 0x66, 0x3a, 0xef, 0xff, 0x69, 0x12, 0x69, 0x98, 0x84, 0xf8, 0x58, 0x6b, 0x93, 0xf6, 0xbd, 0xb5, 0xe5, 0xaf, 0x42,
0xf1, 0x54, 0x0f, 0x16, 0x9c, 0x15, 0x02, 0xc8, 0x0b, 0xfc, 0x30, 0xe4, 0x3c, 0xa3, 0x10, 0x5f, 0xe7, 0xbf, 0x65, 0xef, 0x7a, 0x24, 0x32, 0xa4, 0xf7, 0x16, 0x3f, 0x30, 0x83, 0xa5, 0xe0, 0x95,
0x3b, 0xfc, 0xc4, 0x77, 0xbe, 0x23, 0x3c, 0xde, 0xd0, 0x24, 0x39, 0x2d, 0xe1, 0xe2, 0x41, 0x06, 0x04, 0xf2, 0x0c, 0xdf, 0x8f, 0x85, 0x28, 0x18, 0xa4, 0x73, 0x87, 0x8f, 0xbc, 0xf7, 0x0d, 0xe1,
0x89, 0x34, 0xd1, 0x7f, 0xdd, 0x28, 0x1e, 0x79, 0x86, 0x87, 0x25, 0x4d, 0x77, 0xf2, 0x0a, 0xfb, 0xd5, 0x35, 0xcb, 0xb2, 0x71, 0x09, 0x8a, 0x17, 0x05, 0x64, 0xca, 0x46, 0x77, 0xaa, 0xd1, 0x1c,
0x1d, 0x91, 0x3c, 0xc5, 0x38, 0x87, 0x98, 0x86, 0x9f, 0x5a, 0xcc, 0x34, 0x16, 0x68, 0x39, 0x0a, 0x79, 0x8a, 0x97, 0x35, 0xcb, 0x6f, 0xd4, 0x0c, 0xf9, 0x03, 0x48, 0x1e, 0x63, 0x5c, 0x42, 0xca,
0x46, 0xea, 0xe6, 0x63, 0xcd, 0x81, 0x3c, 0xc2, 0x46, 0x09, 0x89, 0x39, 0x54, 0xf7, 0x6d, 0xe9, 0xe2, 0x4f, 0x7d, 0xce, 0xb6, 0xd6, 0xc8, 0x3f, 0x89, 0x4e, 0xf4, 0xcd, 0xfb, 0x56, 0x00, 0x79,
0xbc, 0xc5, 0x93, 0xce, 0xa1, 0xde, 0xf6, 0x94, 0xb3, 0x71, 0x43, 0xce, 0xfe, 0x37, 0x84, 0x07, 0x88, 0xad, 0x1a, 0x32, 0x7b, 0xa9, 0xef, 0xfb, 0xd0, 0x7b, 0x8d, 0x4f, 0x07, 0x85, 0x66, 0xdb,
0xad, 0x0a, 0x59, 0xe3, 0xa1, 0x0a, 0x8f, 0xcc, 0xce, 0x1a, 0xfb, 0xff, 0xd2, 0x7a, 0x72, 0x19, 0xd1, 0x67, 0xeb, 0x00, 0x9f, 0xc3, 0xef, 0x08, 0x2f, 0xfa, 0x2e, 0xe4, 0x23, 0x5e, 0x6a, 0xf3,
0xd4, 0x0e, 0x5e, 0x6b, 0xad, 0xf3, 0x6d, 0x7b, 0x41, 0x5a, 0xb3, 0x8b, 0x58, 0x27, 0xb0, 0x36, 0xc8, 0x05, 0xdd, 0xf3, 0x6c, 0xe9, 0xf4, 0xcf, 0x3a, 0x4f, 0xe6, 0xa0, 0x46, 0xdd, 0x07, 0x33,
0x0f, 0x47, 0xfb, 0xee, 0xe7, 0xd1, 0xbe, 0xfb, 0xda, 0xd8, 0xe8, 0xd0, 0xd8, 0xe8, 0x47, 0x63, 0xc7, 0xdf, 0x5b, 0x33, 0xb1, 0xdc, 0xb9, 0x98, 0x41, 0x0e, 0xcd, 0x5f, 0xd9, 0xb7, 0x3b, 0xf7,
0xa3, 0x5f, 0x8d, 0x8d, 0xb6, 0xf7, 0xea, 0x6d, 0xad, 0x7e, 0x07, 0x00, 0x00, 0xff, 0xff, 0x61, 0xe8, 0xe7, 0xce, 0x3d, 0xfa, 0xda, 0xb9, 0xe8, 0xb6, 0x73, 0xd1, 0x8f, 0xce, 0x45, 0xbf, 0x3a,
0x65, 0x17, 0x47, 0x85, 0x03, 0x00, 0x00, 0x17, 0x6d, 0x8e, 0xf5, 0x9b, 0xbc, 0xfa, 0x1d, 0x00, 0x00, 0xff, 0xff, 0x7f, 0xee, 0xae, 0xcf,
0xcb, 0x03, 0x00, 0x00,
} }

2
api/services/diff/diff.proto
View File

@ -1,6 +1,6 @@
syntax = "proto3"; syntax = "proto3";
package containerd.v1; package containerd.services.diff.v1;
import "gogoproto/gogo.proto"; import "gogoproto/gogo.proto";
import "google/protobuf/empty.proto"; import "google/protobuf/empty.proto";

81
api/services/events/events.pb.go
View File

@ -9,7 +9,7 @@
github.com/containerd/containerd/api/services/events/events.proto github.com/containerd/containerd/api/services/events/events.proto
It has these top-level messages: It has these top-level messages:
EventStreamRequest StreamEventsRequest
*/ */
package events package events
@ -39,15 +39,15 @@ var _ = math.Inf
// proto package needs to be updated. // proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
type EventStreamRequest struct { type StreamEventsRequest struct {
} }
func (m *EventStreamRequest) Reset() { *m = EventStreamRequest{} } func (m *StreamEventsRequest) Reset() { *m = StreamEventsRequest{} }
func (*EventStreamRequest) ProtoMessage() {} func (*StreamEventsRequest) ProtoMessage() {}
func (*EventStreamRequest) Descriptor() ([]byte, []int) { return fileDescriptorEvents, []int{0} } func (*StreamEventsRequest) Descriptor() ([]byte, []int) { return fileDescriptorEvents, []int{0} }
func init() { func init() {
proto.RegisterType((*EventStreamRequest)(nil), "containerd.v1.services.events.EventStreamRequest") proto.RegisterType((*StreamEventsRequest)(nil), "containerd.services.events.v1.StreamEventsRequest")
} }
// Reference imports to suppress errors if they are not otherwise used. // Reference imports to suppress errors if they are not otherwise used.
@ -61,7 +61,7 @@ const _ = grpc.SupportPackageIsVersion4
// Client API for Events service // Client API for Events service
type EventsClient interface { type EventsClient interface {
EventStream(ctx context.Context, in *EventStreamRequest, opts ...grpc.CallOption) (Events_EventStreamClient, error) Stream(ctx context.Context, in *StreamEventsRequest, opts ...grpc.CallOption) (Events_StreamClient, error)
} }
type eventsClient struct { type eventsClient struct {
@ -72,12 +72,12 @@ func NewEventsClient(cc *grpc.ClientConn) EventsClient {
return &eventsClient{cc} return &eventsClient{cc}
} }
func (c *eventsClient) EventStream(ctx context.Context, in *EventStreamRequest, opts ...grpc.CallOption) (Events_EventStreamClient, error) { func (c *eventsClient) Stream(ctx context.Context, in *StreamEventsRequest, opts ...grpc.CallOption) (Events_StreamClient, error) {
stream, err := grpc.NewClientStream(ctx, &_Events_serviceDesc.Streams[0], c.cc, "/containerd.v1.services.events.Events/EventStream", opts...) stream, err := grpc.NewClientStream(ctx, &_Events_serviceDesc.Streams[0], c.cc, "/containerd.services.events.v1.Events/Stream", opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
x := &eventsEventStreamClient{stream} x := &eventsStreamClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil { if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err return nil, err
} }
@ -87,16 +87,16 @@ func (c *eventsClient) EventStream(ctx context.Context, in *EventStreamRequest,
return x, nil return x, nil
} }
type Events_EventStreamClient interface { type Events_StreamClient interface {
Recv() (*containerd_v1_types.Envelope, error) Recv() (*containerd_v1_types.Envelope, error)
grpc.ClientStream grpc.ClientStream
} }
type eventsEventStreamClient struct { type eventsStreamClient struct {
grpc.ClientStream grpc.ClientStream
} }
func (x *eventsEventStreamClient) Recv() (*containerd_v1_types.Envelope, error) { func (x *eventsStreamClient) Recv() (*containerd_v1_types.Envelope, error) {
m := new(containerd_v1_types.Envelope) m := new(containerd_v1_types.Envelope)
if err := x.ClientStream.RecvMsg(m); err != nil { if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err return nil, err
@ -107,49 +107,49 @@ func (x *eventsEventStreamClient) Recv() (*containerd_v1_types.Envelope, error)
// Server API for Events service // Server API for Events service
type EventsServer interface { type EventsServer interface {
EventStream(*EventStreamRequest, Events_EventStreamServer) error Stream(*StreamEventsRequest, Events_StreamServer) error
} }
func RegisterEventsServer(s *grpc.Server, srv EventsServer) { func RegisterEventsServer(s *grpc.Server, srv EventsServer) {
s.RegisterService(&_Events_serviceDesc, srv) s.RegisterService(&_Events_serviceDesc, srv)
} }
func _Events_EventStream_Handler(srv interface{}, stream grpc.ServerStream) error { func _Events_Stream_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(EventStreamRequest) m := new(StreamEventsRequest)
if err := stream.RecvMsg(m); err != nil { if err := stream.RecvMsg(m); err != nil {
return err return err
} }
return srv.(EventsServer).EventStream(m, &eventsEventStreamServer{stream}) return srv.(EventsServer).Stream(m, &eventsStreamServer{stream})
} }
type Events_EventStreamServer interface { type Events_StreamServer interface {
Send(*containerd_v1_types.Envelope) error Send(*containerd_v1_types.Envelope) error
grpc.ServerStream grpc.ServerStream
} }
type eventsEventStreamServer struct { type eventsStreamServer struct {
grpc.ServerStream grpc.ServerStream
} }
func (x *eventsEventStreamServer) Send(m *containerd_v1_types.Envelope) error { func (x *eventsStreamServer) Send(m *containerd_v1_types.Envelope) error {
return x.ServerStream.SendMsg(m) return x.ServerStream.SendMsg(m)
} }
var _Events_serviceDesc = grpc.ServiceDesc{ var _Events_serviceDesc = grpc.ServiceDesc{
ServiceName: "containerd.v1.services.events.Events", ServiceName: "containerd.services.events.v1.Events",
HandlerType: (*EventsServer)(nil), HandlerType: (*EventsServer)(nil),
Methods: []grpc.MethodDesc{}, Methods: []grpc.MethodDesc{},
Streams: []grpc.StreamDesc{ Streams: []grpc.StreamDesc{
{ {
StreamName: "EventStream", StreamName: "Stream",
Handler: _Events_EventStream_Handler, Handler: _Events_Stream_Handler,
ServerStreams: true, ServerStreams: true,
}, },
}, },
Metadata: "github.com/containerd/containerd/api/services/events/events.proto", Metadata: "github.com/containerd/containerd/api/services/events/events.proto",
} }
func (m *EventStreamRequest) Marshal() (dAtA []byte, err error) { func (m *StreamEventsRequest) 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)
@ -159,7 +159,7 @@ func (m *EventStreamRequest) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil return dAtA[:n], nil
} }
func (m *EventStreamRequest) MarshalTo(dAtA []byte) (int, error) { func (m *StreamEventsRequest) MarshalTo(dAtA []byte) (int, error) {
var i int var i int
_ = i _ = i
var l int var l int
@ -194,7 +194,7 @@ func encodeVarintEvents(dAtA []byte, offset int, v uint64) int {
dAtA[offset] = uint8(v) dAtA[offset] = uint8(v)
return offset + 1 return offset + 1
} }
func (m *EventStreamRequest) Size() (n int) { func (m *StreamEventsRequest) Size() (n int) {
var l int var l int
_ = l _ = l
return n return n
@ -213,11 +213,11 @@ func sovEvents(x uint64) (n int) {
func sozEvents(x uint64) (n int) { func sozEvents(x uint64) (n int) {
return sovEvents(uint64((x << 1) ^ uint64((int64(x) >> 63)))) return sovEvents(uint64((x << 1) ^ uint64((int64(x) >> 63))))
} }
func (this *EventStreamRequest) String() string { func (this *StreamEventsRequest) String() string {
if this == nil { if this == nil {
return "nil" return "nil"
} }
s := strings.Join([]string{`&EventStreamRequest{`, s := strings.Join([]string{`&StreamEventsRequest{`,
`}`, `}`,
}, "") }, "")
return s return s
@ -230,7 +230,7 @@ func valueToStringEvents(v interface{}) string {
pv := reflect.Indirect(rv).Interface() pv := reflect.Indirect(rv).Interface()
return fmt.Sprintf("*%v", pv) return fmt.Sprintf("*%v", pv)
} }
func (m *EventStreamRequest) Unmarshal(dAtA []byte) error { func (m *StreamEventsRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA) l := len(dAtA)
iNdEx := 0 iNdEx := 0
for iNdEx < l { for iNdEx < l {
@ -253,10 +253,10 @@ func (m *EventStreamRequest) 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: EventStreamRequest: wiretype end group for non-group") return fmt.Errorf("proto: StreamEventsRequest: wiretype end group for non-group")
} }
if fieldNum <= 0 { if fieldNum <= 0 {
return fmt.Errorf("proto: EventStreamRequest: illegal tag %d (wire type %d)", fieldNum, wire) return fmt.Errorf("proto: StreamEventsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
} }
switch fieldNum { switch fieldNum {
default: default:
@ -390,17 +390,18 @@ func init() {
} }
var fileDescriptorEvents = []byte{ var fileDescriptorEvents = []byte{
// 192 bytes of a gzipped FileDescriptorProto // 194 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x72, 0x4c, 0xcf, 0x2c, 0xc9, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x72, 0x4c, 0xcf, 0x2c, 0xc9,
0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xce, 0xcf, 0x2b, 0x49, 0xcc, 0xcc, 0x4b, 0x2d, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xce, 0xcf, 0x2b, 0x49, 0xcc, 0xcc, 0x4b, 0x2d,
0x4a, 0x41, 0x66, 0x26, 0x16, 0x64, 0xea, 0x17, 0xa7, 0x16, 0x95, 0x65, 0x26, 0xa7, 0x16, 0xeb, 0x4a, 0x41, 0x66, 0x26, 0x16, 0x64, 0xea, 0x17, 0xa7, 0x16, 0x95, 0x65, 0x26, 0xa7, 0x16, 0xeb,
0xa7, 0x96, 0xa5, 0xe6, 0x95, 0xc0, 0x28, 0xbd, 0x82, 0xa2, 0xfc, 0x92, 0x7c, 0x21, 0x59, 0x84, 0xa7, 0x96, 0xa5, 0xe6, 0x95, 0xc0, 0x28, 0xbd, 0x82, 0xa2, 0xfc, 0x92, 0x7c, 0x21, 0x59, 0x84,
0x62, 0xbd, 0x32, 0x43, 0x3d, 0x98, 0x5a, 0x3d, 0x88, 0x22, 0x29, 0x1b, 0xa2, 0x6c, 0x28, 0xa9, 0x62, 0x3d, 0x98, 0x42, 0x3d, 0xa8, 0x8a, 0x32, 0x43, 0x29, 0x1b, 0xa2, 0x6c, 0x28, 0xa9, 0x2c,
0x2c, 0x80, 0x19, 0x0f, 0x21, 0x21, 0x86, 0x2b, 0x89, 0x70, 0x09, 0xb9, 0x82, 0xb8, 0xc1, 0x25, 0x80, 0x19, 0x0f, 0x21, 0x21, 0x86, 0x2b, 0x89, 0x72, 0x09, 0x07, 0x97, 0x14, 0xa5, 0x26, 0xe6,
0x45, 0xa9, 0x89, 0xb9, 0x41, 0xa9, 0x85, 0xa5, 0xa9, 0xc5, 0x25, 0x46, 0xd9, 0x5c, 0x6c, 0x60, 0xba, 0x82, 0x0d, 0x0c, 0x4a, 0x2d, 0x2c, 0x4d, 0x2d, 0x2e, 0x31, 0x4a, 0xe7, 0x62, 0x83, 0x08,
0xd1, 0x62, 0xa1, 0x44, 0x2e, 0x6e, 0x24, 0x79, 0x21, 0x43, 0x3d, 0xbc, 0x8e, 0xd1, 0xc3, 0x34, 0x08, 0xc5, 0x72, 0xb1, 0x41, 0x14, 0x08, 0x19, 0xe9, 0xe1, 0x75, 0x88, 0x1e, 0x16, 0x73, 0xa4,
0x4b, 0x4a, 0x16, 0x4d, 0x0b, 0xd8, 0x25, 0x7a, 0xae, 0x79, 0x65, 0xa9, 0x39, 0xf9, 0x05, 0xa9, 0x64, 0x91, 0xf5, 0x94, 0x19, 0xea, 0x81, 0x9d, 0xa1, 0xe7, 0x9a, 0x57, 0x96, 0x9a, 0x93, 0x5f,
0x06, 0x8c, 0x4e, 0x12, 0x27, 0x1e, 0xca, 0x31, 0xdc, 0x78, 0x28, 0xc7, 0xd0, 0xf0, 0x48, 0x8e, 0x90, 0x6a, 0xc0, 0xe8, 0x24, 0x71, 0xe2, 0xa1, 0x1c, 0xc3, 0x8d, 0x87, 0x72, 0x0c, 0x0d, 0x8f,
0xf1, 0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18, 0x1f, 0x3c, 0x92, 0x63, 0x4c, 0x62, 0x03, 0xe4, 0x18, 0x4f, 0x3c, 0x92, 0x63, 0xbc, 0xf0, 0x48, 0x8e, 0xf1, 0xc1, 0x23, 0x39, 0xc6, 0x24,
0xbb, 0xd1, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0xd7, 0x73, 0xbd, 0xf1, 0x45, 0x01, 0x00, 0x00, 0x36, 0xb0, 0x03, 0x8d, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x82, 0x06, 0x73, 0x76, 0x42, 0x01,
0x00, 0x00,
} }

6
api/services/events/events.proto
View File

@ -1,11 +1,11 @@
syntax = "proto3"; syntax = "proto3";
package containerd.v1.services.events; package containerd.services.events.v1;
import "github.com/containerd/containerd/api/types/event/event.proto"; import "github.com/containerd/containerd/api/types/event/event.proto";
service Events { service Events {
rpc EventStream(EventStreamRequest) returns (stream containerd.v1.types.Envelope); rpc Stream(StreamEventsRequest) returns (stream containerd.v1.types.Envelope);
} }
message EventStreamRequest {} message StreamEventsRequest {}

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

File diff suppressed because it is too large Load Diff

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

@ -1,6 +1,6 @@
syntax = "proto3"; syntax = "proto3";
package containerd.v1.services.execution; package containerd.services.tasks.v1;
import "google/protobuf/empty.proto"; import "google/protobuf/empty.proto";
import "google/protobuf/any.proto"; import "google/protobuf/any.proto";
@ -11,31 +11,47 @@ import "github.com/containerd/containerd/api/types/task/task.proto";
import "google/protobuf/timestamp.proto"; import "google/protobuf/timestamp.proto";
service Tasks { service Tasks {
rpc Create(CreateRequest) returns (CreateResponse); // Create a task.
rpc Start(StartRequest) returns (google.protobuf.Empty); rpc Create(CreateTaskRequest) returns (CreateTaskResponse);
rpc Delete(DeleteRequest) returns (DeleteResponse);
// Start a task.
rpc Start(StartTaskRequest) returns (google.protobuf.Empty);
// Delete a task and on disk state.
rpc Delete(DeleteTaskRequest) returns (DeleteResponse);
rpc DeleteProcess(DeleteProcessRequest) returns (DeleteResponse); rpc DeleteProcess(DeleteProcessRequest) returns (DeleteResponse);
rpc Info(InfoRequest) returns (InfoResponse);
rpc List(ListRequest) returns (ListResponse); rpc Get(GetTaskRequest) returns (GetTaskResponse);
rpc List(ListTasksRequest) returns (ListTasksResponse);
// Kill a task or process.
rpc Kill(KillRequest) returns (google.protobuf.Empty); rpc Kill(KillRequest) returns (google.protobuf.Empty);
rpc Events(EventsRequest) returns (stream containerd.v1.types.Event);
rpc Exec(ExecRequest) returns (ExecResponse); rpc Exec(ExecProcessRequest) returns (ExecProcessResponse);
rpc Pty(PtyRequest) returns (google.protobuf.Empty);
rpc CloseStdin(CloseStdinRequest) returns (google.protobuf.Empty); rpc ResizePty(ResizePtyRequest) returns (google.protobuf.Empty);
rpc Pause(PauseRequest) returns (google.protobuf.Empty);
rpc Resume(ResumeRequest) returns (google.protobuf.Empty); rpc CloseIO(CloseIORequest) returns (google.protobuf.Empty);
rpc Processes(ProcessesRequest) returns (ProcessesResponse);
rpc Checkpoint(CheckpointRequest) returns (CheckpointResponse); rpc Pause(PauseTaskRequest) returns (google.protobuf.Empty);
rpc Resume(ResumeTaskRequest) returns (google.protobuf.Empty);
rpc ListProcesses(ListProcessesRequest) returns (ListProcessesResponse);
rpc Checkpoint(CheckpointTaskRequest) returns (CheckpointTaskResponse);
} }
message CreateRequest { message CreateTaskRequest {
// NOTE: reserve field 1 for task id.
// ContainerID specifies the container to use for creating this task. // ContainerID specifies the container to use for creating this task.
// //
// The spec from the provided container id will be used to create the // The spec from the provided container id will be used to create the
// task associated with this container. Only one task can be run at a time // task associated with this container. Only one task can be run at a time
// per container. // per container.
//
// This should be created using the Containers service.
string container_id = 2; string container_id = 2;
// RootFS provides the pre-chroot mounts to perform in the shim before // RootFS provides the pre-chroot mounts to perform in the shim before
@ -46,15 +62,15 @@ message CreateRequest {
// the container object. // the container object.
repeated containerd.v1.types.Mount rootfs = 3; repeated containerd.v1.types.Mount rootfs = 3;
string stdin = 5; string stdin = 4;
string stdout = 6; string stdout = 5;
string stderr = 7; string stderr = 6;
bool terminal = 8; bool terminal = 7;
types.Descriptor checkpoint = 9; containerd.v1.types.Descriptor checkpoint = 8;
} }
message CreateResponse { message CreateTaskResponse {
// TODO(stevvooe): We no longer have an id for a task since they are bound // TODO(stevvooe): We no longer have an id for a task since they are bound
// to a single container. Although, we should represent each new task with // to a single container. Although, we should represent each new task with
// an ID so one can differentiate between each instance of a container // an ID so one can differentiate between each instance of a container
@ -68,11 +84,11 @@ message CreateResponse {
uint32 pid = 3; uint32 pid = 3;
} }
message StartRequest { message StartTaskRequest {
string container_id = 1; string container_id = 1;
} }
message DeleteRequest { message DeleteTaskRequest {
string container_id = 1; string container_id = 1;
} }
@ -87,18 +103,19 @@ message DeleteProcessRequest {
uint32 pid = 2; uint32 pid = 2;
} }
message InfoRequest { message GetTaskRequest {
string container_id = 1; string container_id = 1;
} }
message InfoResponse { message GetTaskResponse {
types.Task task = 1; containerd.v1.types.Task task = 1;
} }
message ListRequest { message ListTasksRequest {
string filter = 1;
} }
message ListResponse { message ListTasksResponse {
repeated containerd.v1.types.Task tasks = 1; repeated containerd.v1.types.Task tasks = 1;
} }
@ -111,16 +128,14 @@ message KillRequest {
} }
} }
message EventsRequest { message ExecProcessRequest {
}
message ExecRequest {
// ContainerID specifies the container in which to exec the process. // ContainerID specifies the container in which to exec the process.
string container_id = 1; string container_id = 1;
bool terminal = 2;
string stdin = 3; string stdin = 2;
string stdout = 4; string stdout = 3;
string stderr = 5; string stderr = 4;
bool terminal = 5;
// Spec for starting a process in the target container. // Spec for starting a process in the target container.
// //
@ -128,49 +143,45 @@ message ExecRequest {
google.protobuf.Any spec = 6; google.protobuf.Any spec = 6;
} }
message ExecResponse { message ExecProcessResponse {
uint32 pid = 1; uint32 pid = 1;
} }
message PtyRequest { message ResizePtyRequest {
string container_id = 1; string container_id = 1;
uint32 pid = 2; uint32 pid = 2;
uint32 width = 3; uint32 width = 3;
uint32 height = 4; uint32 height = 4;
} }
message CloseStdinRequest { message CloseIORequest {
string container_id = 1; string container_id = 1;
uint32 pid = 2; uint32 pid = 2;
bool stdin = 3;
} }
message PauseRequest { message PauseTaskRequest {
string container_id = 1; string container_id = 1;
} }
message ResumeRequest { message ResumeTaskRequest {
string container_id = 1; string container_id = 1;
} }
message ProcessesRequest { message ListProcessesRequest {
string container_id = 1; string container_id = 1;
} }
message ProcessesResponse{ message ListProcessesResponse{
repeated containerd.v1.types.Process processes = 1; repeated containerd.v1.types.Process processes = 1;
} }
message CheckpointRequest { message CheckpointTaskRequest {
string container_id = 1; string container_id = 1;
bool allow_tcp = 2; string parent_checkpoint = 2 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false];
bool allow_unix_sockets = 3; map<string, string> options = 3;
bool allow_terminal = 4;
bool file_locks = 5;
repeated string empty_namespaces = 6;
string parent_checkpoint = 7 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false];
bool exit = 8;
} }
message CheckpointResponse { message CheckpointTaskResponse {
repeated types.Descriptor descriptors = 1; repeated containerd.v1.types.Descriptor descriptors = 1;
} }

647
api/services/images/images.pb.go
View File

File diff suppressed because it is too large Load Diff

49
api/services/images/images.proto
View File

@ -1,10 +1,9 @@
syntax = "proto3"; syntax = "proto3";
package containerd.v1; package containerd.services.images.v1;
import "gogoproto/gogo.proto"; import "gogoproto/gogo.proto";
import "google/protobuf/empty.proto"; import "google/protobuf/empty.proto";
import "github.com/containerd/containerd/api/types/mount/mount.proto";
import "github.com/containerd/containerd/api/types/descriptor/descriptor.proto"; import "github.com/containerd/containerd/api/types/descriptor/descriptor.proto";
// Images is a service that allows one to register images with containerd. // Images is a service that allows one to register images with containerd.
@ -20,59 +19,49 @@ import "github.com/containerd/containerd/api/types/descriptor/descriptor.proto";
// As such, this can really be considered a "metadata service". // As such, this can really be considered a "metadata service".
service Images { service Images {
// Get returns an image by name. // Get returns an image by name.
rpc Get(GetRequest) returns (GetResponse); rpc Get(GetImageRequest) returns (GetImageResponse);
// List returns a list of all images known to containerd. // List returns a list of all images known to containerd.
rpc List(ListRequest) returns (ListResponse); rpc List(ListImagesRequest) returns (ListImagesResponse);
// Put assigns the name to a given target image based on the provided // Update assigns the name to a given target image based on the provided
// image. // image.
rpc Put(PutRequest) returns (google.protobuf.Empty); rpc Update(UpdateImageRequest) returns (UpdateImageResponse);
// Delete deletes the image by name. // Delete deletes the image by name.
rpc Delete(DeleteRequest) returns (google.protobuf.Empty); rpc Delete(DeleteImageRequest) returns (google.protobuf.Empty);
} }
message Image { message Image {
string name = 1; string name = 1;
string labels = 2; map<string, string> labels = 2;
types.Descriptor target = 3 [(gogoproto.nullable) = false]; containerd.v1.types.Descriptor target = 3 [(gogoproto.nullable) = false];
} }
message GetRequest { message GetImageRequest {
string name = 1; string name = 1;
// TODO(stevvooe): Consider that we may want to have multiple images under
// the same name or multiple names for the same image. This mapping could
// be truly many to many but we'll need a way to identify an entry.
//
// For now, we consider it unique but an intermediary index could be
// created to allow for a dispatch of images.
} }
message GetResponse { message GetImageResponse {
Image image = 1; Image image = 1;
} }
message PutRequest { message UpdateImageRequest {
Image image = 1 [(gogoproto.nullable) = false]; Image image = 1 [(gogoproto.nullable) = false];
} }
message ListRequest { message UpdateImageResponse {
// TODO(stevvooe): empty for now, need to ad filtration Image image = 1 [(gogoproto.nullable) = false];
// Some common use cases we might consider:
//
// 1. Select by multiple names.
// 2. Select by platform.
// 3. Select by annotations.
} }
message ListResponse { message ListImagesRequest {
string filter = 1;
}
message ListImagesResponse {
repeated Image images = 1 [(gogoproto.nullable) = false]; repeated Image images = 1 [(gogoproto.nullable) = false];
// TODO(stevvooe): Add pagination.
} }
message DeleteRequest { message DeleteImageRequest {
string name = 1; string name = 1;
} }

111
api/services/namespaces/namespace.pb.go
View File

@ -152,16 +152,16 @@ func (*DeleteNamespaceRequest) ProtoMessage() {}
func (*DeleteNamespaceRequest) Descriptor() ([]byte, []int) { return fileDescriptorNamespace, []int{9} } func (*DeleteNamespaceRequest) Descriptor() ([]byte, []int) { return fileDescriptorNamespace, []int{9} }
func init() { func init() {
proto.RegisterType((*Namespace)(nil), "containerd.v1.namespaces.Namespace") proto.RegisterType((*Namespace)(nil), "containerd.services.namespaces.v1.Namespace")
proto.RegisterType((*GetNamespaceRequest)(nil), "containerd.v1.namespaces.GetNamespaceRequest") proto.RegisterType((*GetNamespaceRequest)(nil), "containerd.services.namespaces.v1.GetNamespaceRequest")
proto.RegisterType((*GetNamespaceResponse)(nil), "containerd.v1.namespaces.GetNamespaceResponse") proto.RegisterType((*GetNamespaceResponse)(nil), "containerd.services.namespaces.v1.GetNamespaceResponse")
proto.RegisterType((*ListNamespacesRequest)(nil), "containerd.v1.namespaces.ListNamespacesRequest") proto.RegisterType((*ListNamespacesRequest)(nil), "containerd.services.namespaces.v1.ListNamespacesRequest")
proto.RegisterType((*ListNamespacesResponse)(nil), "containerd.v1.namespaces.ListNamespacesResponse") proto.RegisterType((*ListNamespacesResponse)(nil), "containerd.services.namespaces.v1.ListNamespacesResponse")
proto.RegisterType((*CreateNamespaceRequest)(nil), "containerd.v1.namespaces.CreateNamespaceRequest") proto.RegisterType((*CreateNamespaceRequest)(nil), "containerd.services.namespaces.v1.CreateNamespaceRequest")
proto.RegisterType((*CreateNamespaceResponse)(nil), "containerd.v1.namespaces.CreateNamespaceResponse") proto.RegisterType((*CreateNamespaceResponse)(nil), "containerd.services.namespaces.v1.CreateNamespaceResponse")
proto.RegisterType((*UpdateNamespaceRequest)(nil), "containerd.v1.namespaces.UpdateNamespaceRequest") proto.RegisterType((*UpdateNamespaceRequest)(nil), "containerd.services.namespaces.v1.UpdateNamespaceRequest")
proto.RegisterType((*UpdateNamespaceResponse)(nil), "containerd.v1.namespaces.UpdateNamespaceResponse") proto.RegisterType((*UpdateNamespaceResponse)(nil), "containerd.services.namespaces.v1.UpdateNamespaceResponse")
proto.RegisterType((*DeleteNamespaceRequest)(nil), "containerd.v1.namespaces.DeleteNamespaceRequest") proto.RegisterType((*DeleteNamespaceRequest)(nil), "containerd.services.namespaces.v1.DeleteNamespaceRequest")
} }
// Reference imports to suppress errors if they are not otherwise used. // Reference imports to suppress errors if they are not otherwise used.
@ -192,7 +192,7 @@ func NewNamespacesClient(cc *grpc.ClientConn) NamespacesClient {
func (c *namespacesClient) Get(ctx context.Context, in *GetNamespaceRequest, opts ...grpc.CallOption) (*GetNamespaceResponse, error) { func (c *namespacesClient) Get(ctx context.Context, in *GetNamespaceRequest, opts ...grpc.CallOption) (*GetNamespaceResponse, error) {
out := new(GetNamespaceResponse) out := new(GetNamespaceResponse)
err := grpc.Invoke(ctx, "/containerd.v1.namespaces.Namespaces/Get", in, out, c.cc, opts...) err := grpc.Invoke(ctx, "/containerd.services.namespaces.v1.Namespaces/Get", in, out, c.cc, opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -201,7 +201,7 @@ func (c *namespacesClient) Get(ctx context.Context, in *GetNamespaceRequest, opt
func (c *namespacesClient) List(ctx context.Context, in *ListNamespacesRequest, opts ...grpc.CallOption) (*ListNamespacesResponse, error) { func (c *namespacesClient) List(ctx context.Context, in *ListNamespacesRequest, opts ...grpc.CallOption) (*ListNamespacesResponse, error) {
out := new(ListNamespacesResponse) out := new(ListNamespacesResponse)
err := grpc.Invoke(ctx, "/containerd.v1.namespaces.Namespaces/List", in, out, c.cc, opts...) err := grpc.Invoke(ctx, "/containerd.services.namespaces.v1.Namespaces/List", in, out, c.cc, opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -210,7 +210,7 @@ func (c *namespacesClient) List(ctx context.Context, in *ListNamespacesRequest,
func (c *namespacesClient) Create(ctx context.Context, in *CreateNamespaceRequest, opts ...grpc.CallOption) (*CreateNamespaceResponse, error) { func (c *namespacesClient) Create(ctx context.Context, in *CreateNamespaceRequest, opts ...grpc.CallOption) (*CreateNamespaceResponse, error) {
out := new(CreateNamespaceResponse) out := new(CreateNamespaceResponse)
err := grpc.Invoke(ctx, "/containerd.v1.namespaces.Namespaces/Create", in, out, c.cc, opts...) err := grpc.Invoke(ctx, "/containerd.services.namespaces.v1.Namespaces/Create", in, out, c.cc, opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -219,7 +219,7 @@ func (c *namespacesClient) Create(ctx context.Context, in *CreateNamespaceReques
func (c *namespacesClient) Update(ctx context.Context, in *UpdateNamespaceRequest, opts ...grpc.CallOption) (*UpdateNamespaceResponse, error) { func (c *namespacesClient) Update(ctx context.Context, in *UpdateNamespaceRequest, opts ...grpc.CallOption) (*UpdateNamespaceResponse, error) {
out := new(UpdateNamespaceResponse) out := new(UpdateNamespaceResponse)
err := grpc.Invoke(ctx, "/containerd.v1.namespaces.Namespaces/Update", in, out, c.cc, opts...) err := grpc.Invoke(ctx, "/containerd.services.namespaces.v1.Namespaces/Update", in, out, c.cc, opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -228,7 +228,7 @@ func (c *namespacesClient) Update(ctx context.Context, in *UpdateNamespaceReques
func (c *namespacesClient) Delete(ctx context.Context, in *DeleteNamespaceRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) { func (c *namespacesClient) Delete(ctx context.Context, in *DeleteNamespaceRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) {
out := new(google_protobuf1.Empty) out := new(google_protobuf1.Empty)
err := grpc.Invoke(ctx, "/containerd.v1.namespaces.Namespaces/Delete", in, out, c.cc, opts...) err := grpc.Invoke(ctx, "/containerd.services.namespaces.v1.Namespaces/Delete", in, out, c.cc, opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -259,7 +259,7 @@ func _Namespaces_Get_Handler(srv interface{}, ctx context.Context, dec func(inte
} }
info := &grpc.UnaryServerInfo{ info := &grpc.UnaryServerInfo{
Server: srv, Server: srv,
FullMethod: "/containerd.v1.namespaces.Namespaces/Get", FullMethod: "/containerd.services.namespaces.v1.Namespaces/Get",
} }
handler := func(ctx context.Context, req interface{}) (interface{}, error) { handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(NamespacesServer).Get(ctx, req.(*GetNamespaceRequest)) return srv.(NamespacesServer).Get(ctx, req.(*GetNamespaceRequest))
@ -277,7 +277,7 @@ func _Namespaces_List_Handler(srv interface{}, ctx context.Context, dec func(int
} }
info := &grpc.UnaryServerInfo{ info := &grpc.UnaryServerInfo{
Server: srv, Server: srv,
FullMethod: "/containerd.v1.namespaces.Namespaces/List", FullMethod: "/containerd.services.namespaces.v1.Namespaces/List",
} }
handler := func(ctx context.Context, req interface{}) (interface{}, error) { handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(NamespacesServer).List(ctx, req.(*ListNamespacesRequest)) return srv.(NamespacesServer).List(ctx, req.(*ListNamespacesRequest))
@ -295,7 +295,7 @@ func _Namespaces_Create_Handler(srv interface{}, ctx context.Context, dec func(i
} }
info := &grpc.UnaryServerInfo{ info := &grpc.UnaryServerInfo{
Server: srv, Server: srv,
FullMethod: "/containerd.v1.namespaces.Namespaces/Create", FullMethod: "/containerd.services.namespaces.v1.Namespaces/Create",
} }
handler := func(ctx context.Context, req interface{}) (interface{}, error) { handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(NamespacesServer).Create(ctx, req.(*CreateNamespaceRequest)) return srv.(NamespacesServer).Create(ctx, req.(*CreateNamespaceRequest))
@ -313,7 +313,7 @@ func _Namespaces_Update_Handler(srv interface{}, ctx context.Context, dec func(i
} }
info := &grpc.UnaryServerInfo{ info := &grpc.UnaryServerInfo{
Server: srv, Server: srv,
FullMethod: "/containerd.v1.namespaces.Namespaces/Update", FullMethod: "/containerd.services.namespaces.v1.Namespaces/Update",
} }
handler := func(ctx context.Context, req interface{}) (interface{}, error) { handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(NamespacesServer).Update(ctx, req.(*UpdateNamespaceRequest)) return srv.(NamespacesServer).Update(ctx, req.(*UpdateNamespaceRequest))
@ -331,7 +331,7 @@ func _Namespaces_Delete_Handler(srv interface{}, ctx context.Context, dec func(i
} }
info := &grpc.UnaryServerInfo{ info := &grpc.UnaryServerInfo{
Server: srv, Server: srv,
FullMethod: "/containerd.v1.namespaces.Namespaces/Delete", FullMethod: "/containerd.services.namespaces.v1.Namespaces/Delete",
} }
handler := func(ctx context.Context, req interface{}) (interface{}, error) { handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(NamespacesServer).Delete(ctx, req.(*DeleteNamespaceRequest)) return srv.(NamespacesServer).Delete(ctx, req.(*DeleteNamespaceRequest))
@ -340,7 +340,7 @@ func _Namespaces_Delete_Handler(srv interface{}, ctx context.Context, dec func(i
} }
var _Namespaces_serviceDesc = grpc.ServiceDesc{ var _Namespaces_serviceDesc = grpc.ServiceDesc{
ServiceName: "containerd.v1.namespaces.Namespaces", ServiceName: "containerd.services.namespaces.v1.Namespaces",
HandlerType: (*NamespacesServer)(nil), HandlerType: (*NamespacesServer)(nil),
Methods: []grpc.MethodDesc{ Methods: []grpc.MethodDesc{
{ {
@ -1971,38 +1971,39 @@ func init() {
} }
var fileDescriptorNamespace = []byte{ var fileDescriptorNamespace = []byte{
// 528 bytes of a gzipped FileDescriptorProto // 536 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x54, 0xbd, 0x8e, 0xd3, 0x4c, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x55, 0xc1, 0x6e, 0xd3, 0x40,
0x14, 0xcd, 0x24, 0xf9, 0x2c, 0xe5, 0xba, 0xf9, 0x34, 0x04, 0x63, 0x19, 0xc9, 0x44, 0xa6, 0x59, 0x10, 0xcd, 0x26, 0x21, 0x52, 0xc6, 0x17, 0xb4, 0x04, 0x63, 0x19, 0xc9, 0x04, 0x9f, 0x8a, 0x54,
0x24, 0x18, 0xb3, 0xa1, 0xe1, 0xa7, 0x5b, 0x58, 0x02, 0xd2, 0x42, 0x61, 0x89, 0x7a, 0x35, 0x4e, 0xad, 0x45, 0x90, 0xa0, 0x2d, 0xb7, 0x42, 0x29, 0x87, 0x82, 0x90, 0x25, 0x4e, 0x1c, 0x90, 0x93,
0x26, 0xc6, 0x8a, 0xff, 0xf0, 0x8c, 0x23, 0xa5, 0xe3, 0x0d, 0x78, 0x03, 0x1a, 0x5e, 0x26, 0x25, 0x4c, 0x5c, 0x13, 0xc7, 0x36, 0xde, 0x75, 0xa4, 0x88, 0x03, 0xfc, 0x0d, 0x17, 0x3e, 0x24, 0x47,
0x25, 0x15, 0x62, 0xf3, 0x24, 0xc8, 0x63, 0x27, 0xce, 0x6e, 0x1c, 0x2b, 0x2b, 0x85, 0xee, 0x8e, 0x8e, 0x9c, 0x50, 0x9b, 0x2f, 0x41, 0x5e, 0x3b, 0x71, 0xda, 0x18, 0xe1, 0x46, 0xb4, 0xb7, 0x59,
0x7d, 0x8e, 0xcf, 0xb9, 0xd7, 0xe7, 0x0e, 0xbc, 0xf3, 0x7c, 0xf1, 0x39, 0x73, 0xc9, 0x38, 0x0e, 0xef, 0xcc, 0xbc, 0xb7, 0x4f, 0xef, 0x25, 0xf0, 0xda, 0xf5, 0xc4, 0x69, 0xd2, 0x67, 0x83, 0x70,
0xed, 0x71, 0x1c, 0x09, 0xea, 0x47, 0x2c, 0x9d, 0x6c, 0x97, 0x34, 0xf1, 0x6d, 0xce, 0xd2, 0xb9, 0x62, 0x0d, 0xc2, 0x40, 0x38, 0x5e, 0x80, 0xf1, 0x70, 0xbd, 0x74, 0x22, 0xcf, 0xe2, 0x18, 0x4f,
0x3f, 0x66, 0xdc, 0x8e, 0x68, 0xc8, 0x78, 0x42, 0xaf, 0x95, 0x24, 0x49, 0x63, 0x11, 0x63, 0xbd, 0xbd, 0x01, 0x72, 0x2b, 0x70, 0x26, 0xc8, 0x23, 0xe7, 0x42, 0xc9, 0xa2, 0x38, 0x14, 0x21, 0x7d,
0xe2, 0x90, 0xf9, 0x29, 0xa9, 0x90, 0x46, 0xdf, 0x8b, 0xbd, 0x58, 0x82, 0xec, 0xbc, 0x2a, 0xf0, 0x58, 0xcc, 0xb0, 0x65, 0x3f, 0x2b, 0xfa, 0xd9, 0xf4, 0xb1, 0xde, 0x71, 0x43, 0x37, 0x94, 0xdd,
0xc6, 0x7d, 0x2f, 0x8e, 0xbd, 0x80, 0xd9, 0xf2, 0xe4, 0x66, 0x53, 0x9b, 0x85, 0x89, 0x58, 0x94, 0x56, 0x5a, 0x65, 0x83, 0xfa, 0x7d, 0x37, 0x0c, 0x5d, 0x1f, 0x2d, 0x79, 0xea, 0x27, 0x23, 0x0b,
0x2f, 0x07, 0x37, 0x5f, 0x4e, 0x7d, 0x16, 0x4c, 0x2e, 0x43, 0xca, 0x67, 0x05, 0xc2, 0xfa, 0x81, 0x27, 0x91, 0x98, 0xe5, 0x97, 0xdd, 0xcb, 0x97, 0x23, 0x0f, 0xfd, 0xe1, 0xc7, 0x89, 0xc3, 0xc7,
0xa0, 0xf7, 0x71, 0xad, 0x81, 0x31, 0x74, 0x73, 0x41, 0x1d, 0x0d, 0xd0, 0x49, 0xcf, 0x91, 0x35, 0x59, 0x87, 0xf9, 0x83, 0x40, 0xfb, 0xed, 0x12, 0x86, 0x52, 0x68, 0xa6, 0x98, 0x1a, 0xe9, 0x92,
0x1e, 0x81, 0x12, 0x50, 0x97, 0x05, 0x5c, 0x6f, 0x0f, 0x3a, 0x27, 0xea, 0xd0, 0x26, 0xfb, 0x1c, 0x9d, 0xb6, 0x2d, 0x6b, 0xfa, 0x0e, 0x5a, 0xbe, 0xd3, 0x47, 0x9f, 0x6b, 0xf5, 0x6e, 0x63, 0x47,
0x92, 0xcd, 0x87, 0xc8, 0x85, 0x64, 0x9c, 0x47, 0x22, 0x5d, 0x38, 0x25, 0xdd, 0x78, 0x01, 0xea, 0xe9, 0xed, 0xb1, 0x7f, 0x52, 0x65, 0xab, 0x8d, 0xec, 0x44, 0x8e, 0x1e, 0x05, 0x22, 0x9e, 0xd9,
0xd6, 0x63, 0xfc, 0x3f, 0x74, 0x66, 0x6c, 0x51, 0x4a, 0xe5, 0x25, 0xee, 0xc3, 0x7f, 0x73, 0x1a, 0xf9, 0x1e, 0x7d, 0x1f, 0x94, 0xb5, 0xcf, 0xf4, 0x36, 0x34, 0xc6, 0x38, 0xcb, 0x31, 0xd3, 0x92,
0x64, 0x4c, 0x6f, 0xcb, 0x67, 0xc5, 0xe1, 0x65, 0xfb, 0x39, 0xb2, 0x1e, 0xc1, 0x9d, 0x11, 0x13, 0x76, 0xe0, 0xd6, 0xd4, 0xf1, 0x13, 0xd4, 0xea, 0xf2, 0x5b, 0x76, 0x38, 0xa8, 0xef, 0x11, 0xf3,
0x9b, 0xcf, 0x3b, 0xec, 0x4b, 0xc6, 0xb8, 0xa8, 0xb3, 0x6b, 0x5d, 0x42, 0xff, 0x3a, 0x94, 0x27, 0x11, 0xdc, 0x39, 0x46, 0xb1, 0x5a, 0x6f, 0xe3, 0xe7, 0x04, 0xb9, 0x28, 0xe3, 0x6d, 0x9e, 0x42,
0x71, 0xc4, 0xf3, 0x36, 0x7a, 0x1b, 0xa7, 0x92, 0xa0, 0x0e, 0x1f, 0x1e, 0xd0, 0xc9, 0x59, 0x77, 0xe7, 0x62, 0x2b, 0x8f, 0xc2, 0x80, 0xa7, 0xef, 0x69, 0xaf, 0xc8, 0xca, 0x01, 0xa5, 0xb7, 0x7b,
0xf9, 0xfb, 0x41, 0xcb, 0xa9, 0xb8, 0x96, 0x0d, 0x77, 0x2f, 0x7c, 0x5e, 0x29, 0xf0, 0xb5, 0x1b, 0x95, 0x27, 0x1d, 0x36, 0xe7, 0xbf, 0x1f, 0xd4, 0xec, 0x62, 0x89, 0x69, 0xc1, 0xdd, 0x13, 0x8f,
0x0d, 0x94, 0xa9, 0x1f, 0x08, 0x96, 0x96, 0x7e, 0xca, 0x93, 0x35, 0x06, 0xed, 0x26, 0xa1, 0xf4, 0x17, 0x50, 0x7c, 0x49, 0x4b, 0x85, 0xd6, 0xc8, 0xf3, 0x05, 0xc6, 0x39, 0xb1, 0xfc, 0x64, 0xfa,
0xf4, 0x1e, 0xa0, 0xd2, 0xd4, 0x91, 0x1c, 0xef, 0x2d, 0x4c, 0x6d, 0x91, 0x2d, 0x0a, 0xda, 0xeb, 0xa0, 0x5e, 0x1e, 0xc8, 0xc9, 0xd9, 0x00, 0x05, 0xac, 0x46, 0xa4, 0xe0, 0xdb, 0xb0, 0x5b, 0xdb,
0x94, 0x51, 0xc1, 0x76, 0x86, 0x74, 0xb4, 0xc6, 0x5d, 0xb8, 0xb7, 0x23, 0x71, 0xec, 0xe1, 0x7e, 0x62, 0x7e, 0x02, 0xf5, 0x45, 0x8c, 0x8e, 0xc0, 0x0d, 0xd9, 0xfe, 0xbf, 0x14, 0x63, 0xb8, 0xb7,
0x47, 0xa0, 0x7d, 0x4a, 0x26, 0xff, 0xb2, 0x0f, 0xfc, 0x0a, 0xd4, 0x4c, 0x4a, 0xc8, 0x3d, 0x90, 0x81, 0x75, 0x6d, 0xba, 0x7f, 0x27, 0xa0, 0xbe, 0x8f, 0x86, 0x37, 0xf2, 0x32, 0xfa, 0x1c, 0x94,
0x61, 0x53, 0x87, 0x06, 0x29, 0x56, 0x85, 0xac, 0x57, 0x85, 0xbc, 0xcd, 0x57, 0xe5, 0x03, 0xe5, 0x44, 0x62, 0xc9, 0xf4, 0x48, 0x67, 0x2a, 0x3d, 0x9d, 0x65, 0x01, 0x63, 0xcb, 0x80, 0xb1, 0x57,
0x33, 0x07, 0x0a, 0x78, 0x5e, 0xe7, 0x43, 0xd8, 0xf1, 0x77, 0xec, 0x21, 0x3c, 0x06, 0xed, 0x0d, 0x69, 0xc0, 0xde, 0x38, 0x7c, 0x6c, 0x43, 0xd6, 0x9e, 0xd6, 0xa9, 0x2c, 0x1b, 0x44, 0xaf, 0x4d,
0x0b, 0x58, 0xcd, 0x0c, 0x6a, 0x02, 0x3f, 0xfc, 0xd6, 0x05, 0xa8, 0xb2, 0x85, 0x27, 0xd0, 0x19, 0x96, 0x5d, 0x50, 0x5f, 0xa2, 0x8f, 0x25, 0xaa, 0x94, 0xc4, 0xa4, 0x77, 0xd6, 0x04, 0x28, 0x8c,
0x31, 0x81, 0x9f, 0xec, 0x57, 0xae, 0xd9, 0x24, 0x83, 0x1c, 0x0a, 0x2f, 0x7b, 0xf5, 0xa1, 0x9b, 0x48, 0xa7, 0xd0, 0x38, 0x46, 0x41, 0x9f, 0x56, 0xa0, 0x50, 0x12, 0x44, 0xfd, 0xd9, 0x95, 0xe7,
0x67, 0x1a, 0x37, 0x5c, 0x06, 0xb5, 0x4b, 0x62, 0x3c, 0x3d, 0x9c, 0x50, 0x4a, 0x85, 0xa0, 0x14, 0x72, 0x19, 0xbe, 0x40, 0x33, 0x8d, 0x04, 0xad, 0xf2, 0xeb, 0x52, 0x1a, 0x36, 0x7d, 0x7f, 0x8b,
0xb1, 0xc3, 0x0d, 0xdc, 0xfa, 0xec, 0x1b, 0xa7, 0xb7, 0x60, 0x54, 0x72, 0xc5, 0x0f, 0x6e, 0x92, 0xc9, 0x1c, 0xfc, 0x2b, 0xb4, 0x32, 0xd7, 0xd2, 0x2a, 0x4b, 0xca, 0xc3, 0xa4, 0x1f, 0x6c, 0x33,
0xab, 0x8f, 0x68, 0x93, 0xdc, 0xbe, 0xd0, 0x38, 0xa0, 0x14, 0xff, 0xba, 0x49, 0xae, 0x3e, 0x0d, 0x5a, 0x10, 0xc8, 0xfc, 0x51, 0x89, 0x40, 0xb9, 0xe7, 0x2b, 0x11, 0xf8, 0x9b, 0x0b, 0x3f, 0x40,
0x86, 0xb6, 0x93, 0xd9, 0xf3, 0xfc, 0xee, 0x3f, 0xd3, 0x97, 0x57, 0x66, 0xeb, 0xd7, 0x95, 0xd9, 0x2b, 0xf3, 0x4c, 0x25, 0x02, 0xe5, 0xf6, 0xd2, 0xd5, 0x8d, 0x34, 0x1c, 0xa5, 0xff, 0x45, 0x87,
0xfa, 0xba, 0x32, 0xd1, 0x72, 0x65, 0xa2, 0x9f, 0x2b, 0x13, 0xfd, 0x59, 0x99, 0xc8, 0x55, 0x24, 0xda, 0xfc, 0xdc, 0xa8, 0xfd, 0x3a, 0x37, 0x6a, 0xdf, 0x16, 0x06, 0x99, 0x2f, 0x0c, 0xf2, 0x73,
0xf2, 0xd9, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf0, 0x2e, 0xc3, 0x29, 0xaf, 0x06, 0x00, 0x00, 0x61, 0x90, 0xb3, 0x85, 0x41, 0xfa, 0x2d, 0xd9, 0xf9, 0xe4, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff,
0x88, 0x7f, 0xdb, 0x9f, 0x48, 0x07, 0x00, 0x00,
} }

4
api/services/namespaces/namespace.proto
View File

@ -1,6 +1,6 @@
syntax = "proto3"; syntax = "proto3";
package containerd.v1.namespaces; package containerd.services.namespaces.v1;
import "gogoproto/gogo.proto"; import "gogoproto/gogo.proto";
import "google/protobuf/empty.proto"; import "google/protobuf/empty.proto";
@ -44,7 +44,7 @@ message GetNamespaceResponse {
} }
message ListNamespacesRequest { message ListNamespacesRequest {
string filter = 1; // TODO(stevvooe): Define a filtering syntax to make these queries. string filter = 1;
} }
message ListNamespacesResponse { message ListNamespacesResponse {

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

@ -54,6 +54,7 @@ import github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
import strings "strings" import strings "strings"
import reflect "reflect" import reflect "reflect"
import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
import io "io" import io "io"
@ -252,13 +253,8 @@ func (*ProcessesResponse) ProtoMessage() {}
func (*ProcessesResponse) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{19} } func (*ProcessesResponse) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{19} }
type CheckpointRequest struct { type CheckpointRequest struct {
Exit bool `protobuf:"varint,1,opt,name=exit,proto3" json:"exit,omitempty"` Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
AllowTcp bool `protobuf:"varint,2,opt,name=allow_tcp,json=allowTcp,proto3" json:"allow_tcp,omitempty"` Options map[string]string `protobuf:"bytes,2,rep,name=options" json:"options,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
AllowUnixSockets bool `protobuf:"varint,3,opt,name=allow_unix_sockets,json=allowUnixSockets,proto3" json:"allow_unix_sockets,omitempty"`
AllowTerminal bool `protobuf:"varint,4,opt,name=allow_terminal,json=allowTerminal,proto3" json:"allow_terminal,omitempty"`
FileLocks bool `protobuf:"varint,5,opt,name=file_locks,json=fileLocks,proto3" json:"file_locks,omitempty"`
EmptyNamespaces []string `protobuf:"bytes,6,rep,name=empty_namespaces,json=emptyNamespaces" json:"empty_namespaces,omitempty"`
CheckpointPath string `protobuf:"bytes,7,opt,name=checkpoint_path,json=checkpointPath,proto3" json:"checkpoint_path,omitempty"`
} }
func (m *CheckpointRequest) Reset() { *m = CheckpointRequest{} } func (m *CheckpointRequest) Reset() { *m = CheckpointRequest{} }
@ -266,27 +262,27 @@ func (*CheckpointRequest) ProtoMessage() {}
func (*CheckpointRequest) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{20} } func (*CheckpointRequest) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{20} }
func init() { func init() {
proto.RegisterType((*CreateRequest)(nil), "containerd.v1.services.shim.CreateRequest") proto.RegisterType((*CreateRequest)(nil), "containerd.runtime.linux.shim.v1.CreateRequest")
proto.RegisterType((*CreateResponse)(nil), "containerd.v1.services.shim.CreateResponse") proto.RegisterType((*CreateResponse)(nil), "containerd.runtime.linux.shim.v1.CreateResponse")
proto.RegisterType((*StartRequest)(nil), "containerd.v1.services.shim.StartRequest") proto.RegisterType((*StartRequest)(nil), "containerd.runtime.linux.shim.v1.StartRequest")
proto.RegisterType((*DeleteRequest)(nil), "containerd.v1.services.shim.DeleteRequest") proto.RegisterType((*DeleteRequest)(nil), "containerd.runtime.linux.shim.v1.DeleteRequest")
proto.RegisterType((*DeleteResponse)(nil), "containerd.v1.services.shim.DeleteResponse") proto.RegisterType((*DeleteResponse)(nil), "containerd.runtime.linux.shim.v1.DeleteResponse")
proto.RegisterType((*DeleteProcessRequest)(nil), "containerd.v1.services.shim.DeleteProcessRequest") proto.RegisterType((*DeleteProcessRequest)(nil), "containerd.runtime.linux.shim.v1.DeleteProcessRequest")
proto.RegisterType((*ExecRequest)(nil), "containerd.v1.services.shim.ExecRequest") proto.RegisterType((*ExecRequest)(nil), "containerd.runtime.linux.shim.v1.ExecRequest")
proto.RegisterType((*Rlimit)(nil), "containerd.v1.services.shim.Rlimit") proto.RegisterType((*Rlimit)(nil), "containerd.runtime.linux.shim.v1.Rlimit")
proto.RegisterType((*ExecResponse)(nil), "containerd.v1.services.shim.ExecResponse") proto.RegisterType((*ExecResponse)(nil), "containerd.runtime.linux.shim.v1.ExecResponse")
proto.RegisterType((*PtyRequest)(nil), "containerd.v1.services.shim.PtyRequest") proto.RegisterType((*PtyRequest)(nil), "containerd.runtime.linux.shim.v1.PtyRequest")
proto.RegisterType((*EventsRequest)(nil), "containerd.v1.services.shim.EventsRequest") proto.RegisterType((*EventsRequest)(nil), "containerd.runtime.linux.shim.v1.EventsRequest")
proto.RegisterType((*StateRequest)(nil), "containerd.v1.services.shim.StateRequest") proto.RegisterType((*StateRequest)(nil), "containerd.runtime.linux.shim.v1.StateRequest")
proto.RegisterType((*StateResponse)(nil), "containerd.v1.services.shim.StateResponse") proto.RegisterType((*StateResponse)(nil), "containerd.runtime.linux.shim.v1.StateResponse")
proto.RegisterType((*PauseRequest)(nil), "containerd.v1.services.shim.PauseRequest") proto.RegisterType((*PauseRequest)(nil), "containerd.runtime.linux.shim.v1.PauseRequest")
proto.RegisterType((*ResumeRequest)(nil), "containerd.v1.services.shim.ResumeRequest") proto.RegisterType((*ResumeRequest)(nil), "containerd.runtime.linux.shim.v1.ResumeRequest")
proto.RegisterType((*ExitRequest)(nil), "containerd.v1.services.shim.ExitRequest") proto.RegisterType((*ExitRequest)(nil), "containerd.runtime.linux.shim.v1.ExitRequest")
proto.RegisterType((*KillRequest)(nil), "containerd.v1.services.shim.KillRequest") proto.RegisterType((*KillRequest)(nil), "containerd.runtime.linux.shim.v1.KillRequest")
proto.RegisterType((*CloseStdinRequest)(nil), "containerd.v1.services.shim.CloseStdinRequest") proto.RegisterType((*CloseStdinRequest)(nil), "containerd.runtime.linux.shim.v1.CloseStdinRequest")
proto.RegisterType((*ProcessesRequest)(nil), "containerd.v1.services.shim.ProcessesRequest") proto.RegisterType((*ProcessesRequest)(nil), "containerd.runtime.linux.shim.v1.ProcessesRequest")
proto.RegisterType((*ProcessesResponse)(nil), "containerd.v1.services.shim.ProcessesResponse") proto.RegisterType((*ProcessesResponse)(nil), "containerd.runtime.linux.shim.v1.ProcessesResponse")
proto.RegisterType((*CheckpointRequest)(nil), "containerd.v1.services.shim.CheckpointRequest") proto.RegisterType((*CheckpointRequest)(nil), "containerd.runtime.linux.shim.v1.CheckpointRequest")
} }
// Reference imports to suppress errors if they are not otherwise used. // Reference imports to suppress errors if they are not otherwise used.
@ -327,7 +323,7 @@ func NewShimClient(cc *grpc.ClientConn) ShimClient {
func (c *shimClient) Create(ctx context.Context, in *CreateRequest, opts ...grpc.CallOption) (*CreateResponse, error) { func (c *shimClient) Create(ctx context.Context, in *CreateRequest, opts ...grpc.CallOption) (*CreateResponse, error) {
out := new(CreateResponse) out := new(CreateResponse)
err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/Create", in, out, c.cc, opts...) err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/Create", in, out, c.cc, opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -336,7 +332,7 @@ func (c *shimClient) Create(ctx context.Context, in *CreateRequest, opts ...grpc
func (c *shimClient) Start(ctx context.Context, in *StartRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) { func (c *shimClient) Start(ctx context.Context, in *StartRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) {
out := new(google_protobuf1.Empty) out := new(google_protobuf1.Empty)
err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/Start", in, out, c.cc, opts...) err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/Start", in, out, c.cc, opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -345,7 +341,7 @@ func (c *shimClient) Start(ctx context.Context, in *StartRequest, opts ...grpc.C
func (c *shimClient) Delete(ctx context.Context, in *DeleteRequest, opts ...grpc.CallOption) (*DeleteResponse, error) { func (c *shimClient) Delete(ctx context.Context, in *DeleteRequest, opts ...grpc.CallOption) (*DeleteResponse, error) {
out := new(DeleteResponse) out := new(DeleteResponse)
err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/Delete", in, out, c.cc, opts...) err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/Delete", in, out, c.cc, opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -354,7 +350,7 @@ func (c *shimClient) Delete(ctx context.Context, in *DeleteRequest, opts ...grpc
func (c *shimClient) DeleteProcess(ctx context.Context, in *DeleteProcessRequest, opts ...grpc.CallOption) (*DeleteResponse, error) { func (c *shimClient) DeleteProcess(ctx context.Context, in *DeleteProcessRequest, opts ...grpc.CallOption) (*DeleteResponse, error) {
out := new(DeleteResponse) out := new(DeleteResponse)
err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/DeleteProcess", in, out, c.cc, opts...) err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/DeleteProcess", in, out, c.cc, opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -363,7 +359,7 @@ func (c *shimClient) DeleteProcess(ctx context.Context, in *DeleteProcessRequest
func (c *shimClient) State(ctx context.Context, in *StateRequest, opts ...grpc.CallOption) (*StateResponse, error) { func (c *shimClient) State(ctx context.Context, in *StateRequest, opts ...grpc.CallOption) (*StateResponse, error) {
out := new(StateResponse) out := new(StateResponse)
err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/State", in, out, c.cc, opts...) err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/State", in, out, c.cc, opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -372,7 +368,7 @@ func (c *shimClient) State(ctx context.Context, in *StateRequest, opts ...grpc.C
func (c *shimClient) Processes(ctx context.Context, in *ProcessesRequest, opts ...grpc.CallOption) (*ProcessesResponse, error) { func (c *shimClient) Processes(ctx context.Context, in *ProcessesRequest, opts ...grpc.CallOption) (*ProcessesResponse, error) {
out := new(ProcessesResponse) out := new(ProcessesResponse)
err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/Processes", in, out, c.cc, opts...) err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/Processes", in, out, c.cc, opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -381,7 +377,7 @@ func (c *shimClient) Processes(ctx context.Context, in *ProcessesRequest, opts .
func (c *shimClient) Pause(ctx context.Context, in *PauseRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) { func (c *shimClient) Pause(ctx context.Context, in *PauseRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) {
out := new(google_protobuf1.Empty) out := new(google_protobuf1.Empty)
err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/Pause", in, out, c.cc, opts...) err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/Pause", in, out, c.cc, opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -390,7 +386,7 @@ func (c *shimClient) Pause(ctx context.Context, in *PauseRequest, opts ...grpc.C
func (c *shimClient) Resume(ctx context.Context, in *ResumeRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) { func (c *shimClient) Resume(ctx context.Context, in *ResumeRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) {
out := new(google_protobuf1.Empty) out := new(google_protobuf1.Empty)
err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/Resume", in, out, c.cc, opts...) err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/Resume", in, out, c.cc, opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -399,7 +395,7 @@ func (c *shimClient) Resume(ctx context.Context, in *ResumeRequest, opts ...grpc
func (c *shimClient) Checkpoint(ctx context.Context, in *CheckpointRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) { func (c *shimClient) Checkpoint(ctx context.Context, in *CheckpointRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) {
out := new(google_protobuf1.Empty) out := new(google_protobuf1.Empty)
err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/Checkpoint", in, out, c.cc, opts...) err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/Checkpoint", in, out, c.cc, opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -408,7 +404,7 @@ func (c *shimClient) Checkpoint(ctx context.Context, in *CheckpointRequest, opts
func (c *shimClient) Exit(ctx context.Context, in *ExitRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) { func (c *shimClient) Exit(ctx context.Context, in *ExitRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) {
out := new(google_protobuf1.Empty) out := new(google_protobuf1.Empty)
err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/Exit", in, out, c.cc, opts...) err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/Exit", in, out, c.cc, opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -416,7 +412,7 @@ func (c *shimClient) Exit(ctx context.Context, in *ExitRequest, opts ...grpc.Cal
} }
func (c *shimClient) Events(ctx context.Context, in *EventsRequest, opts ...grpc.CallOption) (Shim_EventsClient, error) { func (c *shimClient) Events(ctx context.Context, in *EventsRequest, opts ...grpc.CallOption) (Shim_EventsClient, error) {
stream, err := grpc.NewClientStream(ctx, &_Shim_serviceDesc.Streams[0], c.cc, "/containerd.v1.services.shim.Shim/Events", opts...) stream, err := grpc.NewClientStream(ctx, &_Shim_serviceDesc.Streams[0], c.cc, "/containerd.runtime.linux.shim.v1.Shim/Events", opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -449,7 +445,7 @@ func (x *shimEventsClient) Recv() (*containerd_v1_types1.Event, error) {
func (c *shimClient) Kill(ctx context.Context, in *KillRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) { func (c *shimClient) Kill(ctx context.Context, in *KillRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) {
out := new(google_protobuf1.Empty) out := new(google_protobuf1.Empty)
err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/Kill", in, out, c.cc, opts...) err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/Kill", in, out, c.cc, opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -458,7 +454,7 @@ func (c *shimClient) Kill(ctx context.Context, in *KillRequest, opts ...grpc.Cal
func (c *shimClient) Exec(ctx context.Context, in *ExecRequest, opts ...grpc.CallOption) (*ExecResponse, error) { func (c *shimClient) Exec(ctx context.Context, in *ExecRequest, opts ...grpc.CallOption) (*ExecResponse, error) {
out := new(ExecResponse) out := new(ExecResponse)
err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/Exec", in, out, c.cc, opts...) err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/Exec", in, out, c.cc, opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -467,7 +463,7 @@ func (c *shimClient) Exec(ctx context.Context, in *ExecRequest, opts ...grpc.Cal
func (c *shimClient) Pty(ctx context.Context, in *PtyRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) { func (c *shimClient) Pty(ctx context.Context, in *PtyRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) {
out := new(google_protobuf1.Empty) out := new(google_protobuf1.Empty)
err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/Pty", in, out, c.cc, opts...) err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/Pty", in, out, c.cc, opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -476,7 +472,7 @@ func (c *shimClient) Pty(ctx context.Context, in *PtyRequest, opts ...grpc.CallO
func (c *shimClient) CloseStdin(ctx context.Context, in *CloseStdinRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) { func (c *shimClient) CloseStdin(ctx context.Context, in *CloseStdinRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) {
out := new(google_protobuf1.Empty) out := new(google_protobuf1.Empty)
err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/CloseStdin", in, out, c.cc, opts...) err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/CloseStdin", in, out, c.cc, opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -517,7 +513,7 @@ func _Shim_Create_Handler(srv interface{}, ctx context.Context, dec func(interfa
} }
info := &grpc.UnaryServerInfo{ info := &grpc.UnaryServerInfo{
Server: srv, Server: srv,
FullMethod: "/containerd.v1.services.shim.Shim/Create", FullMethod: "/containerd.runtime.linux.shim.v1.Shim/Create",
} }
handler := func(ctx context.Context, req interface{}) (interface{}, error) { handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ShimServer).Create(ctx, req.(*CreateRequest)) return srv.(ShimServer).Create(ctx, req.(*CreateRequest))
@ -535,7 +531,7 @@ func _Shim_Start_Handler(srv interface{}, ctx context.Context, dec func(interfac
} }
info := &grpc.UnaryServerInfo{ info := &grpc.UnaryServerInfo{
Server: srv, Server: srv,
FullMethod: "/containerd.v1.services.shim.Shim/Start", FullMethod: "/containerd.runtime.linux.shim.v1.Shim/Start",
} }
handler := func(ctx context.Context, req interface{}) (interface{}, error) { handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ShimServer).Start(ctx, req.(*StartRequest)) return srv.(ShimServer).Start(ctx, req.(*StartRequest))
@ -553,7 +549,7 @@ func _Shim_Delete_Handler(srv interface{}, ctx context.Context, dec func(interfa
} }
info := &grpc.UnaryServerInfo{ info := &grpc.UnaryServerInfo{
Server: srv, Server: srv,
FullMethod: "/containerd.v1.services.shim.Shim/Delete", FullMethod: "/containerd.runtime.linux.shim.v1.Shim/Delete",
} }
handler := func(ctx context.Context, req interface{}) (interface{}, error) { handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ShimServer).Delete(ctx, req.(*DeleteRequest)) return srv.(ShimServer).Delete(ctx, req.(*DeleteRequest))
@ -571,7 +567,7 @@ func _Shim_DeleteProcess_Handler(srv interface{}, ctx context.Context, dec func(
} }
info := &grpc.UnaryServerInfo{ info := &grpc.UnaryServerInfo{
Server: srv, Server: srv,
FullMethod: "/containerd.v1.services.shim.Shim/DeleteProcess", FullMethod: "/containerd.runtime.linux.shim.v1.Shim/DeleteProcess",
} }
handler := func(ctx context.Context, req interface{}) (interface{}, error) { handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ShimServer).DeleteProcess(ctx, req.(*DeleteProcessRequest)) return srv.(ShimServer).DeleteProcess(ctx, req.(*DeleteProcessRequest))
@ -589,7 +585,7 @@ func _Shim_State_Handler(srv interface{}, ctx context.Context, dec func(interfac
} }
info := &grpc.UnaryServerInfo{ info := &grpc.UnaryServerInfo{
Server: srv, Server: srv,
FullMethod: "/containerd.v1.services.shim.Shim/State", FullMethod: "/containerd.runtime.linux.shim.v1.Shim/State",
} }
handler := func(ctx context.Context, req interface{}) (interface{}, error) { handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ShimServer).State(ctx, req.(*StateRequest)) return srv.(ShimServer).State(ctx, req.(*StateRequest))
@ -607,7 +603,7 @@ func _Shim_Processes_Handler(srv interface{}, ctx context.Context, dec func(inte
} }
info := &grpc.UnaryServerInfo{ info := &grpc.UnaryServerInfo{
Server: srv, Server: srv,
FullMethod: "/containerd.v1.services.shim.Shim/Processes", FullMethod: "/containerd.runtime.linux.shim.v1.Shim/Processes",
} }
handler := func(ctx context.Context, req interface{}) (interface{}, error) { handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ShimServer).Processes(ctx, req.(*ProcessesRequest)) return srv.(ShimServer).Processes(ctx, req.(*ProcessesRequest))
@ -625,7 +621,7 @@ func _Shim_Pause_Handler(srv interface{}, ctx context.Context, dec func(interfac
} }
info := &grpc.UnaryServerInfo{ info := &grpc.UnaryServerInfo{
Server: srv, Server: srv,
FullMethod: "/containerd.v1.services.shim.Shim/Pause", FullMethod: "/containerd.runtime.linux.shim.v1.Shim/Pause",
} }
handler := func(ctx context.Context, req interface{}) (interface{}, error) { handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ShimServer).Pause(ctx, req.(*PauseRequest)) return srv.(ShimServer).Pause(ctx, req.(*PauseRequest))
@ -643,7 +639,7 @@ func _Shim_Resume_Handler(srv interface{}, ctx context.Context, dec func(interfa
} }
info := &grpc.UnaryServerInfo{ info := &grpc.UnaryServerInfo{
Server: srv, Server: srv,
FullMethod: "/containerd.v1.services.shim.Shim/Resume", FullMethod: "/containerd.runtime.linux.shim.v1.Shim/Resume",
} }
handler := func(ctx context.Context, req interface{}) (interface{}, error) { handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ShimServer).Resume(ctx, req.(*ResumeRequest)) return srv.(ShimServer).Resume(ctx, req.(*ResumeRequest))
@ -661,7 +657,7 @@ func _Shim_Checkpoint_Handler(srv interface{}, ctx context.Context, dec func(int
} }
info := &grpc.UnaryServerInfo{ info := &grpc.UnaryServerInfo{
Server: srv, Server: srv,
FullMethod: "/containerd.v1.services.shim.Shim/Checkpoint", FullMethod: "/containerd.runtime.linux.shim.v1.Shim/Checkpoint",
} }
handler := func(ctx context.Context, req interface{}) (interface{}, error) { handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ShimServer).Checkpoint(ctx, req.(*CheckpointRequest)) return srv.(ShimServer).Checkpoint(ctx, req.(*CheckpointRequest))
@ -679,7 +675,7 @@ func _Shim_Exit_Handler(srv interface{}, ctx context.Context, dec func(interface
} }
info := &grpc.UnaryServerInfo{ info := &grpc.UnaryServerInfo{
Server: srv, Server: srv,
FullMethod: "/containerd.v1.services.shim.Shim/Exit", FullMethod: "/containerd.runtime.linux.shim.v1.Shim/Exit",
} }
handler := func(ctx context.Context, req interface{}) (interface{}, error) { handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ShimServer).Exit(ctx, req.(*ExitRequest)) return srv.(ShimServer).Exit(ctx, req.(*ExitRequest))
@ -718,7 +714,7 @@ func _Shim_Kill_Handler(srv interface{}, ctx context.Context, dec func(interface
} }
info := &grpc.UnaryServerInfo{ info := &grpc.UnaryServerInfo{
Server: srv, Server: srv,
FullMethod: "/containerd.v1.services.shim.Shim/Kill", FullMethod: "/containerd.runtime.linux.shim.v1.Shim/Kill",
} }
handler := func(ctx context.Context, req interface{}) (interface{}, error) { handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ShimServer).Kill(ctx, req.(*KillRequest)) return srv.(ShimServer).Kill(ctx, req.(*KillRequest))
@ -736,7 +732,7 @@ func _Shim_Exec_Handler(srv interface{}, ctx context.Context, dec func(interface
} }
info := &grpc.UnaryServerInfo{ info := &grpc.UnaryServerInfo{
Server: srv, Server: srv,
FullMethod: "/containerd.v1.services.shim.Shim/Exec", FullMethod: "/containerd.runtime.linux.shim.v1.Shim/Exec",
} }
handler := func(ctx context.Context, req interface{}) (interface{}, error) { handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ShimServer).Exec(ctx, req.(*ExecRequest)) return srv.(ShimServer).Exec(ctx, req.(*ExecRequest))
@ -754,7 +750,7 @@ func _Shim_Pty_Handler(srv interface{}, ctx context.Context, dec func(interface{
} }
info := &grpc.UnaryServerInfo{ info := &grpc.UnaryServerInfo{
Server: srv, Server: srv,
FullMethod: "/containerd.v1.services.shim.Shim/Pty", FullMethod: "/containerd.runtime.linux.shim.v1.Shim/Pty",
} }
handler := func(ctx context.Context, req interface{}) (interface{}, error) { handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ShimServer).Pty(ctx, req.(*PtyRequest)) return srv.(ShimServer).Pty(ctx, req.(*PtyRequest))
@ -772,7 +768,7 @@ func _Shim_CloseStdin_Handler(srv interface{}, ctx context.Context, dec func(int
} }
info := &grpc.UnaryServerInfo{ info := &grpc.UnaryServerInfo{
Server: srv, Server: srv,
FullMethod: "/containerd.v1.services.shim.Shim/CloseStdin", FullMethod: "/containerd.runtime.linux.shim.v1.Shim/CloseStdin",
} }
handler := func(ctx context.Context, req interface{}) (interface{}, error) { handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ShimServer).CloseStdin(ctx, req.(*CloseStdinRequest)) return srv.(ShimServer).CloseStdin(ctx, req.(*CloseStdinRequest))
@ -781,7 +777,7 @@ func _Shim_CloseStdin_Handler(srv interface{}, ctx context.Context, dec func(int
} }
var _Shim_serviceDesc = grpc.ServiceDesc{ var _Shim_serviceDesc = grpc.ServiceDesc{
ServiceName: "containerd.v1.services.shim.Shim", ServiceName: "containerd.runtime.linux.shim.v1.Shim",
HandlerType: (*ShimServer)(nil), HandlerType: (*ShimServer)(nil),
Methods: []grpc.MethodDesc{ Methods: []grpc.MethodDesc{
{ {
@ -1508,77 +1504,29 @@ func (m *CheckpointRequest) MarshalTo(dAtA []byte) (int, error) {
_ = i _ = i
var l int var l int
_ = l _ = l
if m.Exit { if len(m.Path) > 0 {
dAtA[i] = 0x8 dAtA[i] = 0xa
i++
if m.Exit {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i++ i++
i = encodeVarintShim(dAtA, i, uint64(len(m.Path)))
i += copy(dAtA[i:], m.Path)
} }
if m.AllowTcp { if len(m.Options) > 0 {
dAtA[i] = 0x10 for k, _ := range m.Options {
i++ dAtA[i] = 0x12
if m.AllowTcp {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i++
}
if m.AllowUnixSockets {
dAtA[i] = 0x18
i++
if m.AllowUnixSockets {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i++
}
if m.AllowTerminal {
dAtA[i] = 0x20
i++
if m.AllowTerminal {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i++
}
if m.FileLocks {
dAtA[i] = 0x28
i++
if m.FileLocks {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i++
}
if len(m.EmptyNamespaces) > 0 {
for _, s := range m.EmptyNamespaces {
dAtA[i] = 0x32
i++ i++
l = len(s) v := m.Options[k]
for l >= 1<<7 { mapSize := 1 + len(k) + sovShim(uint64(len(k))) + 1 + len(v) + sovShim(uint64(len(v)))
dAtA[i] = uint8(uint64(l)&0x7f | 0x80) i = encodeVarintShim(dAtA, i, uint64(mapSize))
l >>= 7 dAtA[i] = 0xa
i++
}
dAtA[i] = uint8(l)
i++ i++
i += copy(dAtA[i:], s) i = encodeVarintShim(dAtA, i, uint64(len(k)))
i += copy(dAtA[i:], k)
dAtA[i] = 0x12
i++
i = encodeVarintShim(dAtA, i, uint64(len(v)))
i += copy(dAtA[i:], v)
} }
} }
if len(m.CheckpointPath) > 0 {
dAtA[i] = 0x3a
i++
i = encodeVarintShim(dAtA, i, uint64(len(m.CheckpointPath)))
i += copy(dAtA[i:], m.CheckpointPath)
}
return i, nil return i, nil
} }
@ -1885,31 +1833,18 @@ func (m *ProcessesResponse) Size() (n int) {
func (m *CheckpointRequest) Size() (n int) { func (m *CheckpointRequest) Size() (n int) {
var l int var l int
_ = l _ = l
if m.Exit { l = len(m.Path)
n += 2
}
if m.AllowTcp {
n += 2
}
if m.AllowUnixSockets {
n += 2
}
if m.AllowTerminal {
n += 2
}
if m.FileLocks {
n += 2
}
if len(m.EmptyNamespaces) > 0 {
for _, s := range m.EmptyNamespaces {
l = len(s)
n += 1 + l + sovShim(uint64(l))
}
}
l = len(m.CheckpointPath)
if l > 0 { if l > 0 {
n += 1 + l + sovShim(uint64(l)) n += 1 + l + sovShim(uint64(l))
} }
if len(m.Options) > 0 {
for k, v := range m.Options {
_ = k
_ = v
mapEntrySize := 1 + len(k) + sovShim(uint64(len(k))) + 1 + len(v) + sovShim(uint64(len(v)))
n += mapEntrySize + 1 + sovShim(uint64(mapEntrySize))
}
}
return n return n
} }
@ -2152,14 +2087,19 @@ func (this *CheckpointRequest) String() string {
if this == nil { if this == nil {
return "nil" return "nil"
} }
keysForOptions := make([]string, 0, len(this.Options))
for k, _ := range this.Options {
keysForOptions = append(keysForOptions, k)
}
github_com_gogo_protobuf_sortkeys.Strings(keysForOptions)
mapStringForOptions := "map[string]string{"
for _, k := range keysForOptions {
mapStringForOptions += fmt.Sprintf("%v: %v,", k, this.Options[k])
}
mapStringForOptions += "}"
s := strings.Join([]string{`&CheckpointRequest{`, s := strings.Join([]string{`&CheckpointRequest{`,
`Exit:` + fmt.Sprintf("%v", this.Exit) + `,`, `Path:` + fmt.Sprintf("%v", this.Path) + `,`,
`AllowTcp:` + fmt.Sprintf("%v", this.AllowTcp) + `,`, `Options:` + mapStringForOptions + `,`,
`AllowUnixSockets:` + fmt.Sprintf("%v", this.AllowUnixSockets) + `,`,
`AllowTerminal:` + fmt.Sprintf("%v", this.AllowTerminal) + `,`,
`FileLocks:` + fmt.Sprintf("%v", this.FileLocks) + `,`,
`EmptyNamespaces:` + fmt.Sprintf("%v", this.EmptyNamespaces) + `,`,
`CheckpointPath:` + fmt.Sprintf("%v", this.CheckpointPath) + `,`,
`}`, `}`,
}, "") }, "")
return s return s
@ -4246,108 +4186,8 @@ func (m *CheckpointRequest) Unmarshal(dAtA []byte) error {
} }
switch fieldNum { switch fieldNum {
case 1: case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Exit", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowShim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.Exit = bool(v != 0)
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field AllowTcp", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowShim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.AllowTcp = bool(v != 0)
case 3:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field AllowUnixSockets", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowShim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.AllowUnixSockets = bool(v != 0)
case 4:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field AllowTerminal", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowShim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.AllowTerminal = bool(v != 0)
case 5:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field FileLocks", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowShim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.FileLocks = bool(v != 0)
case 6:
if wireType != 2 { if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field EmptyNamespaces", wireType) return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
} }
var stringLen uint64 var stringLen uint64
for shift := uint(0); ; shift += 7 { for shift := uint(0); ; shift += 7 {
@ -4372,13 +4212,13 @@ func (m *CheckpointRequest) Unmarshal(dAtA []byte) error {
if postIndex > l { if postIndex > l {
return io.ErrUnexpectedEOF return io.ErrUnexpectedEOF
} }
m.EmptyNamespaces = append(m.EmptyNamespaces, string(dAtA[iNdEx:postIndex])) m.Path = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex iNdEx = postIndex
case 7: case 2:
if wireType != 2 { if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field CheckpointPath", wireType) return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
} }
var stringLen uint64 var msglen int
for shift := uint(0); ; shift += 7 { for shift := uint(0); ; shift += 7 {
if shift >= 64 { if shift >= 64 {
return ErrIntOverflowShim return ErrIntOverflowShim
@ -4388,20 +4228,107 @@ func (m *CheckpointRequest) Unmarshal(dAtA []byte) error {
} }
b := dAtA[iNdEx] b := dAtA[iNdEx]
iNdEx++ iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift msglen |= (int(b) & 0x7F) << shift
if b < 0x80 { if b < 0x80 {
break break
} }
} }
intStringLen := int(stringLen) if msglen < 0 {
if intStringLen < 0 {
return ErrInvalidLengthShim return ErrInvalidLengthShim
} }
postIndex := iNdEx + intStringLen postIndex := iNdEx + msglen
if postIndex > l { if postIndex > l {
return io.ErrUnexpectedEOF return io.ErrUnexpectedEOF
} }
m.CheckpointPath = string(dAtA[iNdEx:postIndex]) var keykey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowShim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
keykey |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
var stringLenmapkey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowShim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLenmapkey |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLenmapkey := int(stringLenmapkey)
if intStringLenmapkey < 0 {
return ErrInvalidLengthShim
}
postStringIndexmapkey := iNdEx + intStringLenmapkey
if postStringIndexmapkey > l {
return io.ErrUnexpectedEOF
}
mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
iNdEx = postStringIndexmapkey
if m.Options == nil {
m.Options = make(map[string]string)
}
if iNdEx < postIndex {
var valuekey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowShim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
valuekey |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
var stringLenmapvalue uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowShim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLenmapvalue |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLenmapvalue := int(stringLenmapvalue)
if intStringLenmapvalue < 0 {
return ErrInvalidLengthShim
}
postStringIndexmapvalue := iNdEx + intStringLenmapvalue
if postStringIndexmapvalue > l {
return io.ErrUnexpectedEOF
}
mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
iNdEx = postStringIndexmapvalue
m.Options[mapkey] = mapvalue
} else {
var mapvalue string
m.Options[mapkey] = mapvalue
}
iNdEx = postIndex iNdEx = postIndex
default: default:
iNdEx = preIndex iNdEx = preIndex
@ -4534,78 +4461,75 @@ func init() {
} }
var fileDescriptorShim = []byte{ var fileDescriptorShim = []byte{
// 1168 bytes of a gzipped FileDescriptorProto // 1110 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xcd, 0x6e, 0x23, 0x45, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xcd, 0x6f, 0xe3, 0x44,
0x10, 0xce, 0xd8, 0x8e, 0x63, 0x97, 0xd7, 0x4e, 0xd2, 0x8a, 0xa2, 0x59, 0x07, 0x9c, 0x68, 0xa4, 0x14, 0x5f, 0x27, 0x69, 0x9a, 0xbc, 0x34, 0xa5, 0x1d, 0x55, 0x95, 0xd7, 0x8b, 0xd2, 0xca, 0x12,
0xd5, 0x3a, 0x59, 0x18, 0xb3, 0xd9, 0xdb, 0x0a, 0x0e, 0xf9, 0x43, 0x2c, 0x04, 0xb0, 0x26, 0xe1, 0x52, 0xc5, 0x87, 0xb3, 0x9b, 0x4a, 0x08, 0x55, 0x20, 0xd1, 0xaf, 0xc3, 0x6a, 0x59, 0x35, 0xb8,
0x84, 0x84, 0x35, 0x19, 0x77, 0xec, 0x26, 0xe3, 0xe9, 0x61, 0xba, 0x9d, 0x4d, 0x6e, 0x3c, 0x00, 0x48, 0x08, 0x2e, 0x95, 0x9b, 0x4c, 0xe3, 0x51, 0x6d, 0x8f, 0xf1, 0x8c, 0x43, 0x73, 0xe3, 0x4f,
0x07, 0xae, 0xdc, 0x39, 0xf0, 0x28, 0x39, 0x72, 0x83, 0xd3, 0xc2, 0xe6, 0x49, 0x50, 0xff, 0xcc, 0x80, 0x23, 0x77, 0xfe, 0x0f, 0xae, 0x3d, 0x72, 0x83, 0xd3, 0xc2, 0xf6, 0x2f, 0x41, 0xf3, 0x61,
0x8f, 0x93, 0x8c, 0xed, 0x48, 0x5c, 0x46, 0xdd, 0xd5, 0xd5, 0xd5, 0x55, 0xf5, 0x7d, 0x55, 0x35, 0xc7, 0x69, 0x6b, 0xea, 0xae, 0xb8, 0x58, 0xf3, 0xde, 0xbc, 0x79, 0x9f, 0xbf, 0xf7, 0x9e, 0xe1,
0xf0, 0xd9, 0x80, 0xf0, 0xe1, 0xf8, 0xcc, 0xf6, 0xe8, 0xa8, 0xe3, 0xd1, 0x80, 0xbb, 0x24, 0xc0, 0x8b, 0x09, 0xe1, 0x7e, 0x7a, 0xee, 0x8c, 0x68, 0xd8, 0x1f, 0xd1, 0x88, 0x7b, 0x24, 0xc2, 0xc9,
0x51, 0x3f, 0xbb, 0x74, 0x43, 0xd2, 0x61, 0x38, 0xba, 0x24, 0x1e, 0x66, 0x1d, 0x36, 0x24, 0x23, 0xb8, 0x78, 0xf4, 0x62, 0xd2, 0x67, 0x38, 0x99, 0x92, 0x11, 0x66, 0x7d, 0xe6, 0x93, 0x50, 0x7e,
0xf9, 0xb1, 0xc3, 0x88, 0x72, 0x8a, 0x36, 0x52, 0x45, 0xfb, 0xf2, 0xa5, 0x1d, 0xeb, 0xd9, 0x42, 0x9c, 0x38, 0xa1, 0x9c, 0xa2, 0xed, 0xb9, 0xa0, 0x93, 0xa4, 0x11, 0x27, 0x21, 0x76, 0x02, 0x12,
0xa5, 0xf9, 0x74, 0x40, 0xe9, 0xc0, 0xc7, 0x1d, 0xa9, 0x7a, 0x36, 0x3e, 0xef, 0xb8, 0xc1, 0xb5, 0xa5, 0x57, 0x8e, 0x14, 0x9a, 0xbe, 0xb0, 0x9e, 0x4e, 0x28, 0x9d, 0x04, 0xb8, 0x2f, 0xe5, 0xcf,
0xba, 0xd7, 0xdc, 0xb8, 0x7b, 0x84, 0x47, 0x21, 0x8f, 0x0f, 0xd7, 0x06, 0x74, 0x40, 0xe5, 0xb2, 0xd3, 0x8b, 0xbe, 0x17, 0xcd, 0xd4, 0x63, 0xeb, 0xd9, 0xed, 0x2b, 0x1c, 0xc6, 0x3c, 0xbb, 0xdc,
0x23, 0x56, 0x5a, 0xfa, 0xe9, 0x5c, 0x9e, 0xf2, 0xeb, 0x10, 0xb3, 0xce, 0x88, 0x8e, 0x03, 0xae, 0x98, 0xd0, 0x09, 0x95, 0xc7, 0xbe, 0x38, 0x69, 0xee, 0xe7, 0x95, 0xdc, 0xe5, 0xb3, 0x18, 0xb3,
0xbe, 0xfa, 0xf6, 0xeb, 0x47, 0xdc, 0xe6, 0x2e, 0xbb, 0x90, 0x1f, 0x7d, 0x77, 0xf3, 0xae, 0xb3, 0x7e, 0x48, 0xd3, 0x88, 0xab, 0xaf, 0x7e, 0xbd, 0xf7, 0x88, 0xd7, 0xdc, 0x63, 0x97, 0xf2, 0xa3,
0x9c, 0x8c, 0x30, 0xe3, 0xee, 0x28, 0x54, 0x0a, 0xd6, 0x5f, 0x05, 0xa8, 0x1f, 0x44, 0xd8, 0xe5, 0xdf, 0x6e, 0xdd, 0x76, 0x56, 0xc4, 0xca, 0xb8, 0x17, 0xc6, 0x4a, 0xc0, 0xfe, 0xb3, 0x06, 0xdd,
0xd8, 0xc1, 0x3f, 0x8d, 0x31, 0xe3, 0x68, 0x1d, 0x0a, 0xa4, 0x6f, 0x1a, 0x5b, 0x46, 0xbb, 0xba, 0xc3, 0x04, 0x7b, 0x1c, 0xbb, 0xf8, 0x87, 0x14, 0x33, 0x8e, 0x36, 0xa1, 0x46, 0xc6, 0xa6, 0xb1,
0x5f, 0xbe, 0x7d, 0xb7, 0x59, 0x78, 0x73, 0xe8, 0x14, 0x48, 0x1f, 0xad, 0x43, 0xf9, 0x6c, 0x1c, 0x6d, 0xec, 0xb4, 0x0f, 0x9a, 0x37, 0x6f, 0xb6, 0x6a, 0x2f, 0x8f, 0xdc, 0x1a, 0x19, 0xa3, 0x4d,
0xf4, 0x7d, 0x6c, 0x16, 0xc4, 0x99, 0xa3, 0x77, 0xc8, 0x84, 0xa5, 0x68, 0x1c, 0x08, 0xbb, 0x66, 0x68, 0x9e, 0xa7, 0xd1, 0x38, 0xc0, 0x66, 0x4d, 0xdc, 0xb9, 0x9a, 0x42, 0x26, 0x2c, 0xeb, 0x1c,
0x51, 0x1e, 0xc4, 0x5b, 0xf4, 0x14, 0x2a, 0x01, 0xed, 0x85, 0xe4, 0x92, 0x72, 0xb3, 0xb4, 0x65, 0x9a, 0x75, 0x79, 0x91, 0x91, 0xe8, 0x29, 0xb4, 0x22, 0x7a, 0x16, 0x93, 0x29, 0xe5, 0x66, 0x63,
0xb4, 0x2b, 0xce, 0x52, 0x40, 0xbb, 0x62, 0x8b, 0x9a, 0x50, 0xe1, 0x38, 0x1a, 0x91, 0xc0, 0xf5, 0xdb, 0xd8, 0x69, 0xb9, 0xcb, 0x11, 0x1d, 0x0a, 0x12, 0x59, 0xd0, 0xe2, 0x38, 0x09, 0x49, 0xe4,
0xcd, 0x45, 0x79, 0x94, 0xec, 0xd1, 0x1a, 0x2c, 0x32, 0xde, 0x27, 0x81, 0x59, 0x96, 0xe6, 0xd4, 0x05, 0xe6, 0x92, 0xbc, 0xca, 0x69, 0xb4, 0x01, 0x4b, 0x8c, 0x8f, 0x49, 0x64, 0x36, 0xa5, 0x3a,
0x46, 0x3c, 0xcf, 0x78, 0x9f, 0x8e, 0xb9, 0xb9, 0xa4, 0x9e, 0x57, 0x3b, 0x2d, 0xc7, 0x51, 0x64, 0x45, 0x08, 0xf3, 0x8c, 0x8f, 0x69, 0xca, 0xcd, 0x65, 0x65, 0x5e, 0x51, 0x9a, 0x8f, 0x93, 0xc4,
0x56, 0x12, 0x39, 0x8e, 0x22, 0xb4, 0x0b, 0xe5, 0x88, 0x52, 0x7e, 0xce, 0xcc, 0xea, 0x56, 0xb1, 0x6c, 0xe5, 0x7c, 0x9c, 0x24, 0x68, 0x00, 0xcd, 0x84, 0x52, 0x7e, 0xc1, 0xcc, 0xf6, 0x76, 0x7d,
0x5d, 0xdb, 0x6d, 0xda, 0x93, 0x78, 0xcb, 0x7c, 0xd9, 0x5f, 0x8b, 0x3c, 0x3b, 0x5a, 0x13, 0xb5, 0xa7, 0x33, 0xb0, 0x9c, 0x42, 0xd1, 0xa7, 0x2f, 0x1c, 0x99, 0x2f, 0xe7, 0xb5, 0xc8, 0xb3, 0xab,
0x00, 0xbc, 0x21, 0xf6, 0x2e, 0x42, 0x4a, 0x02, 0x6e, 0x82, 0xb4, 0x97, 0x91, 0xa0, 0x17, 0xb0, 0x25, 0x51, 0x0f, 0x60, 0xe4, 0xe3, 0xd1, 0x65, 0x4c, 0x49, 0xc4, 0x4d, 0x90, 0xfa, 0x0a, 0x1c,
0x1a, 0xba, 0x11, 0x0e, 0x78, 0x2f, 0xa3, 0x56, 0x93, 0x6a, 0x2b, 0xea, 0xe0, 0x20, 0x91, 0x5b, 0xf4, 0x11, 0xac, 0xc7, 0x5e, 0x82, 0x23, 0x7e, 0x56, 0x10, 0xeb, 0x48, 0xb1, 0x35, 0x75, 0x71,
0x16, 0x34, 0xe2, 0xc4, 0xb2, 0x90, 0x06, 0x0c, 0xa3, 0x15, 0x28, 0x86, 0x3a, 0xb5, 0x75, 0x47, 0x98, 0xf3, 0x6d, 0x1b, 0x56, 0xb3, 0xc4, 0xb2, 0x98, 0x46, 0x0c, 0xa3, 0x35, 0xa8, 0xc7, 0x3a,
0x2c, 0xad, 0x06, 0x3c, 0x39, 0xe1, 0x6e, 0xc4, 0x75, 0xee, 0xad, 0x65, 0xa8, 0x1f, 0x62, 0x1f, 0xb5, 0x5d, 0x57, 0x1c, 0xed, 0x55, 0x58, 0x39, 0xe5, 0x5e, 0xc2, 0x75, 0xee, 0xed, 0xf7, 0xa0,
0x27, 0x60, 0x58, 0x1c, 0x1a, 0xb1, 0x40, 0x1b, 0xd9, 0x84, 0x1a, 0xbe, 0x22, 0xbc, 0xc7, 0xb8, 0x7b, 0x84, 0x03, 0x9c, 0x17, 0xc3, 0xe6, 0xb0, 0x9a, 0x31, 0xb4, 0x92, 0x2d, 0xe8, 0xe0, 0x2b,
0xcb, 0xc7, 0x4c, 0x1b, 0x03, 0x21, 0x3a, 0x91, 0x12, 0xb4, 0x07, 0x55, 0xb1, 0xc3, 0xfd, 0x9e, 0xc2, 0xcf, 0x18, 0xf7, 0x78, 0xca, 0xb4, 0x32, 0x10, 0xac, 0x53, 0xc9, 0x41, 0xfb, 0xd0, 0x16,
0xcb, 0x25, 0x54, 0x22, 0x76, 0x45, 0x03, 0x3b, 0xa6, 0x81, 0x7d, 0x1a, 0xd3, 0x60, 0xbf, 0x72, 0x14, 0x1e, 0x9f, 0x79, 0x5c, 0x96, 0x4a, 0xc4, 0xae, 0x60, 0xe0, 0x64, 0x30, 0x70, 0xbe, 0xc9,
0xf3, 0x6e, 0x73, 0xe1, 0xd7, 0x7f, 0x36, 0x0d, 0xa7, 0xa2, 0xae, 0xed, 0x71, 0xab, 0x0d, 0x6b, 0x60, 0x70, 0xd0, 0xba, 0x7e, 0xb3, 0xf5, 0xe4, 0xe7, 0xbf, 0xb7, 0x0c, 0xb7, 0xa5, 0x9e, 0xed,
0xea, 0xd5, 0x6e, 0x44, 0x3d, 0xcc, 0x58, 0x4c, 0x8d, 0xfb, 0x01, 0xfc, 0x66, 0x40, 0xed, 0xe8, 0x73, 0x7b, 0x07, 0x36, 0x94, 0xd5, 0x61, 0x42, 0x47, 0x98, 0xb1, 0x0c, 0x1a, 0x77, 0x03, 0xf8,
0x0a, 0x7b, 0xb1, 0x46, 0x16, 0x57, 0x23, 0x0f, 0xd7, 0xc2, 0xc3, 0xb8, 0x16, 0x73, 0x70, 0x2d, 0xd5, 0x80, 0xce, 0xf1, 0x15, 0x1e, 0x65, 0x12, 0xc5, 0xba, 0x1a, 0x65, 0x75, 0xad, 0xdd, 0x5f,
0x4d, 0xe0, 0xda, 0x86, 0x12, 0x0b, 0xb1, 0x27, 0x59, 0x53, 0xdb, 0x5d, 0xbb, 0x17, 0xd9, 0x5e, 0xd7, 0x7a, 0x49, 0x5d, 0x1b, 0x0b, 0x75, 0xdd, 0x81, 0x06, 0x8b, 0xf1, 0x48, 0xa2, 0xa6, 0x33,
0x70, 0xed, 0x48, 0x0d, 0xeb, 0x10, 0xca, 0x8e, 0x4f, 0x46, 0x84, 0x23, 0x04, 0x25, 0x01, 0xb7, 0xd8, 0xb8, 0x13, 0xd9, 0x7e, 0x34, 0x73, 0xa5, 0x84, 0x7d, 0x04, 0x4d, 0x37, 0x20, 0x21, 0xe1,
0x22, 0xb5, 0x23, 0xd7, 0x42, 0x36, 0x74, 0xa3, 0xbe, 0x74, 0xa6, 0xe4, 0xc8, 0xb5, 0x90, 0x31, 0x08, 0x41, 0x43, 0x94, 0x5b, 0x81, 0xda, 0x95, 0x67, 0xc1, 0xf3, 0xbd, 0x64, 0x2c, 0x9d, 0x69,
0x7a, 0xae, 0x3c, 0x29, 0x39, 0x72, 0x6d, 0x6d, 0xc1, 0x13, 0x15, 0x60, 0x2e, 0x88, 0xc7, 0x00, 0xb8, 0xf2, 0x2c, 0x78, 0x8c, 0x5e, 0x28, 0x4f, 0x1a, 0xae, 0x3c, 0xdb, 0xdb, 0xb0, 0xa2, 0x02,
0x5d, 0x7e, 0x9d, 0x9b, 0x23, 0x11, 0xf7, 0x5b, 0xd2, 0xe7, 0x43, 0xf9, 0x54, 0xdd, 0x51, 0x1b, 0x2c, 0x2d, 0xe2, 0x57, 0x00, 0x43, 0x3e, 0x2b, 0xcd, 0x91, 0x88, 0xfb, 0x47, 0x32, 0xe6, 0xbe,
0x11, 0xdf, 0x10, 0x93, 0xc1, 0x50, 0xbd, 0x56, 0x77, 0xf4, 0x4e, 0x50, 0xe0, 0xe8, 0x12, 0x07, 0x34, 0xd5, 0x75, 0x15, 0x21, 0xe2, 0xf3, 0x31, 0x99, 0xf8, 0xca, 0x5a, 0xd7, 0xd5, 0x94, 0x80,
0x3c, 0x4e, 0xba, 0xe6, 0x48, 0x4a, 0x89, 0xdf, 0x0b, 0x50, 0xd7, 0x02, 0xed, 0xd2, 0x63, 0x2b, 0xc0, 0xf1, 0x14, 0x47, 0x3c, 0x4b, 0xba, 0xc6, 0xc8, 0x1c, 0x12, 0xbf, 0xd5, 0xa0, 0xab, 0x19,
0x56, 0xbb, 0x58, 0x4c, 0x5d, 0x7c, 0x25, 0x92, 0x2d, 0xf9, 0x24, 0x92, 0xdd, 0xd8, 0xdd, 0x78, 0xda, 0xa5, 0xc7, 0x76, 0xac, 0x76, 0xb1, 0x3e, 0x77, 0x71, 0x57, 0x24, 0x5b, 0xe2, 0x49, 0x24,
0xb0, 0x58, 0x14, 0xc1, 0x1c, 0xad, 0x8a, 0x5e, 0x43, 0x35, 0x54, 0xfc, 0xc0, 0xcc, 0x5c, 0x94, 0x7b, 0x75, 0xf0, 0xec, 0xde, 0x66, 0x51, 0x00, 0x73, 0xb5, 0x28, 0xda, 0x83, 0x76, 0xac, 0xf0,
0x45, 0xf6, 0xc1, 0x83, 0xf7, 0x62, 0x16, 0xa5, 0xea, 0xff, 0x53, 0x8d, 0x67, 0xd9, 0x56, 0x9d, 0x81, 0x99, 0xb9, 0x24, 0x9b, 0xec, 0xfd, 0x7b, 0xdf, 0x65, 0x28, 0x9a, 0x8b, 0xff, 0x4f, 0x3d,
0x64, 0x9b, 0x48, 0x5b, 0xd7, 0x1d, 0x33, 0x9c, 0x29, 0x2d, 0x07, 0xb3, 0xf1, 0x28, 0x11, 0xd4, 0x5e, 0x44, 0x5b, 0x7b, 0x11, 0x6d, 0x22, 0x6d, 0x43, 0x2f, 0x65, 0xb8, 0xd0, 0x5a, 0x2e, 0x66,
0x05, 0x73, 0x49, 0x52, 0x7a, 0x6f, 0xa0, 0xf6, 0x15, 0xf1, 0xfd, 0xb4, 0x0b, 0x96, 0x19, 0x19, 0x69, 0x98, 0x33, 0xba, 0x02, 0xb9, 0x24, 0x6f, 0xbd, 0x97, 0xd0, 0x79, 0x45, 0x82, 0x60, 0x3e,
0xc4, 0x34, 0xae, 0x3b, 0x7a, 0x27, 0x72, 0xe7, 0xfa, 0xbe, 0x4c, 0x68, 0xc5, 0x11, 0xcb, 0xfb, 0x05, 0x9b, 0x8c, 0x4c, 0x32, 0x18, 0x77, 0x5d, 0x4d, 0x89, 0xdc, 0x79, 0x41, 0x20, 0x13, 0xda,
0xd9, 0xb4, 0x9e, 0xc1, 0xea, 0x81, 0x4f, 0x19, 0x3e, 0x11, 0x41, 0xe5, 0xd7, 0xce, 0x0e, 0xac, 0x72, 0xc5, 0xf1, 0x6e, 0x36, 0xed, 0x0f, 0x60, 0xfd, 0x30, 0xa0, 0x0c, 0x9f, 0x8a, 0xa0, 0xca,
0x74, 0xe3, 0x84, 0xcc, 0x68, 0xbe, 0xd6, 0xb7, 0xb0, 0x9a, 0xd1, 0xd5, 0xb8, 0x4f, 0x00, 0x60, 0x7b, 0xe7, 0x43, 0x58, 0x1b, 0x66, 0x09, 0x79, 0x60, 0xf8, 0xda, 0x27, 0xb0, 0x5e, 0x90, 0xd5,
0x3c, 0x0a, 0x00, 0xeb, 0x97, 0x02, 0xac, 0xa6, 0xcd, 0x2a, 0x7e, 0x1e, 0x41, 0x49, 0x34, 0x01, 0x75, 0x5f, 0x28, 0x80, 0xf1, 0xa8, 0x02, 0xd8, 0xbf, 0x1b, 0xb0, 0x3e, 0x1f, 0x56, 0x99, 0x79,
0x5d, 0xba, 0x72, 0x8d, 0x36, 0xa0, 0xea, 0xfa, 0x3e, 0x7d, 0xdb, 0xe3, 0x5e, 0xa8, 0xe3, 0xae, 0x04, 0x8d, 0xd8, 0xe3, 0x7e, 0xd6, 0x28, 0xe2, 0x8c, 0xbe, 0x87, 0x65, 0x1a, 0x73, 0x42, 0x23,
0x48, 0xc1, 0xa9, 0x17, 0xa2, 0x8f, 0x00, 0xa9, 0xc3, 0x71, 0x40, 0xae, 0x7a, 0x8c, 0x7a, 0x17, 0x66, 0xd6, 0xa4, 0x8d, 0x2f, 0x9d, 0x87, 0xd6, 0xa7, 0x73, 0x47, 0xb3, 0x73, 0xa2, 0x54, 0x1c,
0x98, 0x33, 0x99, 0x8b, 0x8a, 0xb3, 0x22, 0x4f, 0xbe, 0x0b, 0xc8, 0xd5, 0x89, 0x92, 0xa3, 0x67, 0x47, 0x3c, 0x99, 0xb9, 0x99, 0x42, 0x6b, 0x0f, 0x56, 0x8a, 0x17, 0x22, 0x49, 0x97, 0x78, 0xa6,
0xd0, 0xd0, 0xa6, 0x62, 0xd4, 0xd4, 0x58, 0xa8, 0x2b, 0x7b, 0x71, 0xa3, 0xf8, 0x10, 0xe0, 0x9c, 0xcd, 0x8b, 0xa3, 0x00, 0xca, 0xd4, 0x0b, 0xd2, 0x0c, 0xc2, 0x8a, 0xd8, 0xab, 0x7d, 0x66, 0x0c,
0xf8, 0xb8, 0xe7, 0x53, 0xef, 0x82, 0xe9, 0xf1, 0x50, 0x15, 0x92, 0x63, 0x21, 0x40, 0xdb, 0xb0, 0x7e, 0xe9, 0x40, 0xe3, 0xd4, 0x27, 0x21, 0xba, 0x84, 0xa6, 0x1a, 0xb4, 0xa8, 0x5f, 0xc1, 0xb3,
0x22, 0x47, 0x6e, 0x2f, 0x70, 0x47, 0x98, 0x85, 0xae, 0x87, 0x99, 0x59, 0xde, 0x2a, 0xb6, 0xab, 0xe2, 0xae, 0xb3, 0x9e, 0x57, 0x7f, 0xa0, 0x73, 0x7e, 0x02, 0x4b, 0x72, 0x62, 0x23, 0xe7, 0xe1,
0xce, 0xb2, 0x94, 0x7f, 0x93, 0x88, 0xd1, 0x73, 0x58, 0x4e, 0x3b, 0x75, 0x2f, 0x74, 0xf9, 0x50, 0xa7, 0xc5, 0xd1, 0x6e, 0x6d, 0xde, 0x99, 0x54, 0xc7, 0xe2, 0xbf, 0x41, 0x78, 0xaf, 0x66, 0x6d,
0x33, 0xab, 0x91, 0x8a, 0xbb, 0x2e, 0x1f, 0xee, 0xfe, 0x01, 0x50, 0x3a, 0x19, 0x92, 0x11, 0x72, 0x15, 0xef, 0x17, 0x96, 0x43, 0x15, 0xef, 0x6f, 0x2d, 0x8f, 0x59, 0xb6, 0x5f, 0x34, 0x22, 0xd0,
0xa1, 0xac, 0xba, 0x36, 0xda, 0xb1, 0xa7, 0xfc, 0x20, 0xd8, 0x13, 0x33, 0xb3, 0xf9, 0x62, 0x2e, 0xa7, 0x55, 0x55, 0x2c, 0x6e, 0x82, 0x77, 0x30, 0xed, 0xcb, 0xc4, 0x71, 0x5c, 0x31, 0x71, 0xf3,
0x5d, 0x0d, 0xdb, 0x97, 0xb0, 0x28, 0x9b, 0x3e, 0xda, 0x9e, 0x7a, 0x2b, 0x3b, 0x18, 0x9a, 0xeb, 0x28, 0xfb, 0x95, 0xe5, 0xb5, 0x25, 0x0e, 0xed, 0xbc, 0x57, 0xd0, 0xe0, 0xe1, 0xd7, 0xb7, 0x9b,
0xf7, 0xfa, 0xdc, 0x91, 0x08, 0x55, 0xb8, 0xab, 0x3a, 0xf5, 0x0c, 0x77, 0x27, 0xa6, 0xca, 0x0c, 0xd0, 0xda, 0x7d, 0xd4, 0x9b, 0x39, 0x30, 0xe4, 0xbc, 0xa9, 0x12, 0x5f, 0x71, 0x30, 0x95, 0x02,
0x77, 0xef, 0x0c, 0x1c, 0x1a, 0xcf, 0x24, 0xcd, 0x22, 0xf4, 0x72, 0x8e, 0xdb, 0x93, 0x83, 0xe3, 0xe3, 0x6b, 0x68, 0xaa, 0x81, 0x55, 0x05, 0x18, 0x0b, 0xa3, 0xad, 0x54, 0xe5, 0x77, 0x00, 0xf3,
0x71, 0x0f, 0xfe, 0x20, 0xf3, 0xc3, 0xf1, 0xec, 0xfc, 0xa4, 0x11, 0xed, 0xcc, 0xa3, 0xaa, 0xed, 0xce, 0x44, 0xbb, 0xef, 0xd0, 0xc7, 0xa5, 0xaa, 0x5f, 0x43, 0x43, 0x4c, 0x53, 0xf4, 0xc9, 0xc3,
0xff, 0x08, 0xd5, 0xa4, 0x96, 0xd0, 0xc7, 0x53, 0x2f, 0xde, 0xad, 0xcf, 0xa6, 0x3d, 0xaf, 0x7a, 0x4a, 0x0b, 0x53, 0xb7, 0x54, 0xdd, 0xb7, 0xd0, 0x54, 0x5b, 0xb0, 0x4a, 0xf0, 0x0b, 0xfb, 0xd2,
0x8a, 0xb5, 0xec, 0x42, 0x33, 0x62, 0xc9, 0x76, 0xaa, 0x5c, 0xac, 0x8f, 0xa1, 0xac, 0x3a, 0xd8, 0xba, 0xff, 0x47, 0x4f, 0xca, 0x3c, 0x37, 0x84, 0x9f, 0x62, 0xcc, 0x57, 0xf1, 0xb3, 0xb0, 0x0e,
0x0c, 0xac, 0x27, 0xda, 0x5c, 0xae, 0xb5, 0x53, 0x80, 0xb4, 0xfe, 0xd1, 0xf4, 0xb8, 0xee, 0x35, 0x4a, 0xfd, 0xc4, 0x22, 0x6c, 0x3c, 0xaa, 0x16, 0x76, 0xfe, 0x9b, 0x64, 0x39, 0x55, 0xc5, 0x35,
0x8a, 0x5c, 0xab, 0x5f, 0x40, 0x49, 0x34, 0x55, 0xd4, 0x9e, 0x6a, 0x2f, 0xd3, 0x77, 0x73, 0x2d, 0xb8, 0x5e, 0x41, 0x7d, 0xc8, 0x67, 0xe8, 0xe3, 0x0a, 0xd0, 0xca, 0xff, 0x44, 0xfe, 0x13, 0x05,
0x39, 0x50, 0x56, 0x73, 0x70, 0x46, 0xb4, 0x13, 0xc3, 0xb2, 0xf9, 0xf0, 0x5f, 0x9e, 0xd4, 0xf9, 0xf9, 0x7a, 0xaa, 0x84, 0x82, 0xdb, 0xcb, 0xac, 0x4c, 0xf5, 0x81, 0x79, 0xfd, 0xb6, 0xf7, 0xe4,
0xc4, 0x10, 0xde, 0x89, 0x1e, 0x3f, 0xc3, 0xbb, 0xcc, 0x18, 0xc8, 0xf5, 0xee, 0x7b, 0x11, 0x27, 0xaf, 0xb7, 0xbd, 0x27, 0x3f, 0xdd, 0xf4, 0x8c, 0xeb, 0x9b, 0x9e, 0xf1, 0xc7, 0x4d, 0xcf, 0xf8,
0xf6, 0x66, 0xc6, 0x99, 0xfc, 0x19, 0x35, 0xb7, 0xe7, 0xd0, 0xd4, 0xa4, 0xf9, 0x1c, 0x8a, 0x5d, 0xe7, 0xa6, 0x67, 0x9c, 0x37, 0xa5, 0xe4, 0xee, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xd3, 0x47,
0x7e, 0x8d, 0x9e, 0x4f, 0xa7, 0x4c, 0xf2, 0xcb, 0x31, 0x15, 0xe2, 0x64, 0x0e, 0xcd, 0x82, 0xf8, 0xdf, 0xa8, 0xba, 0x0d, 0x00, 0x00,
0xee, 0xc0, 0xca, 0xb3, 0xba, 0x6f, 0xde, 0xbc, 0x6f, 0x2d, 0xfc, 0xfd, 0xbe, 0xb5, 0xf0, 0xf3,
0x6d, 0xcb, 0xb8, 0xb9, 0x6d, 0x19, 0x7f, 0xde, 0xb6, 0x8c, 0x7f, 0x6f, 0x5b, 0xc6, 0x59, 0x59,
0x6a, 0xbe, 0xfa, 0x2f, 0x00, 0x00, 0xff, 0xff, 0xd9, 0x7f, 0x4d, 0x1e, 0x99, 0x0d, 0x00, 0x00,
} }

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

@ -1,6 +1,6 @@
syntax = "proto3"; syntax = "proto3";
package containerd.v1.services.shim; package containerd.runtime.linux.shim.v1;
import "google/protobuf/any.proto"; import "google/protobuf/any.proto";
import "google/protobuf/empty.proto"; import "google/protobuf/empty.proto";
@ -135,11 +135,6 @@ message ProcessesResponse{
} }
message CheckpointRequest { message CheckpointRequest {
bool exit = 1; string path = 1;
bool allow_tcp = 2; map<string, string> options = 2;
bool allow_unix_sockets = 3;
bool allow_terminal = 4;
bool file_locks = 5;
repeated string empty_namespaces = 6;
string checkpoint_path = 7;
} }

964
api/services/snapshot/snapshots.pb.go
View File

File diff suppressed because it is too large Load Diff

47
api/services/snapshot/snapshots.proto
View File

@ -1,29 +1,41 @@
syntax = "proto3"; syntax = "proto3";
package containerd.v1.snapshot; package containerd.services.snapshots.v1;
import "gogoproto/gogo.proto"; import "gogoproto/gogo.proto";
import "google/protobuf/empty.proto"; import "google/protobuf/empty.proto";
import "github.com/containerd/containerd/api/types/mount/mount.proto"; import "github.com/containerd/containerd/api/types/mount/mount.proto";
// Snapshot service manages snapshots // Snapshot service manages snapshots
service Snapshot { service Snapshots {
rpc Prepare(PrepareRequest) returns (MountsResponse); rpc Prepare(PrepareSnapshotRequest) returns (PrepareSnapshotResponse);
rpc View(PrepareRequest) returns (MountsResponse); rpc View(ViewSnapshotRequest) returns (ViewSnapshotResponse);
rpc Mounts(MountsRequest) returns (MountsResponse); rpc Mounts(MountsRequest) returns (MountsResponse);
rpc Commit(CommitRequest) returns (google.protobuf.Empty); rpc Commit(CommitSnapshotRequest) returns (google.protobuf.Empty);
rpc Remove(RemoveRequest) returns (google.protobuf.Empty); rpc Remove(RemoveSnapshotRequest) returns (google.protobuf.Empty);
rpc Stat(StatRequest) returns (StatResponse); rpc Stat(StatSnapshotRequest) returns (StatSnapshotResponse);
rpc List(ListRequest) returns (stream ListResponse); rpc List(ListSnapshotsRequest) returns (stream ListSnapshotsResponse);
rpc Usage(UsageRequest) returns (UsageResponse); rpc Usage(UsageRequest) returns (UsageResponse);
// "Snapshot" prepares a new set of mounts from existing name
} }
message PrepareRequest { message PrepareSnapshotRequest {
string key = 1; string key = 1;
string parent = 2; string parent = 2;
} }
message PrepareSnapshotResponse {
repeated containerd.v1.types.Mount mounts = 1;
}
message ViewSnapshotRequest {
string key = 1;
string parent = 2;
}
message ViewSnapshotResponse {
repeated containerd.v1.types.Mount mounts = 1;
}
message MountsRequest { message MountsRequest {
string key = 1; string key = 1;
} }
@ -32,16 +44,16 @@ message MountsResponse {
repeated containerd.v1.types.Mount mounts = 1; repeated containerd.v1.types.Mount mounts = 1;
} }
message RemoveRequest { message RemoveSnapshotRequest {
string key = 1; string key = 1;
} }
message CommitRequest { message CommitSnapshotRequest {
string name = 1; string name = 1;
string key = 2; string key = 2;
} }
message StatRequest { message StatSnapshotRequest {
string key = 1; string key = 1;
} }
@ -61,13 +73,14 @@ message Info {
bool readonly = 4; bool readonly = 4;
} }
message StatResponse { message StatSnapshotResponse {
Info info = 1 [(gogoproto.nullable) = false]; Info info = 1 [(gogoproto.nullable) = false];
} }
message ListRequest{} message ListSnapshotsRequest{
}
message ListResponse { message ListSnapshotsResponse {
repeated Info info = 1 [(gogoproto.nullable) = false]; repeated Info info = 1 [(gogoproto.nullable) = false];
} }
@ -76,6 +89,6 @@ message UsageRequest {
} }
message UsageResponse { message UsageResponse {
int64 inodes = 2;
int64 size = 1; int64 size = 1;
int64 inodes = 2;
} }

32
api/services/version/version.pb.go
View File

@ -50,7 +50,7 @@ func (*VersionResponse) ProtoMessage() {}
func (*VersionResponse) Descriptor() ([]byte, []int) { return fileDescriptorVersion, []int{0} } func (*VersionResponse) Descriptor() ([]byte, []int) { return fileDescriptorVersion, []int{0} }
func init() { func init() {
proto.RegisterType((*VersionResponse)(nil), "containerd.v1.VersionResponse") proto.RegisterType((*VersionResponse)(nil), "containerd.services.version.v1.VersionResponse")
} }
// Reference imports to suppress errors if they are not otherwise used. // Reference imports to suppress errors if they are not otherwise used.
@ -77,7 +77,7 @@ func NewVersionClient(cc *grpc.ClientConn) VersionClient {
func (c *versionClient) Version(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*VersionResponse, error) { func (c *versionClient) Version(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*VersionResponse, error) {
out := new(VersionResponse) out := new(VersionResponse)
err := grpc.Invoke(ctx, "/containerd.v1.Version/Version", in, out, c.cc, opts...) err := grpc.Invoke(ctx, "/containerd.services.version.v1.Version/Version", in, out, c.cc, opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -104,7 +104,7 @@ func _Version_Version_Handler(srv interface{}, ctx context.Context, dec func(int
} }
info := &grpc.UnaryServerInfo{ info := &grpc.UnaryServerInfo{
Server: srv, Server: srv,
FullMethod: "/containerd.v1.Version/Version", FullMethod: "/containerd.services.version.v1.Version/Version",
} }
handler := func(ctx context.Context, req interface{}) (interface{}, error) { handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(VersionServer).Version(ctx, req.(*google_protobuf.Empty)) return srv.(VersionServer).Version(ctx, req.(*google_protobuf.Empty))
@ -113,7 +113,7 @@ func _Version_Version_Handler(srv interface{}, ctx context.Context, dec func(int
} }
var _Version_serviceDesc = grpc.ServiceDesc{ var _Version_serviceDesc = grpc.ServiceDesc{
ServiceName: "containerd.v1.Version", ServiceName: "containerd.services.version.v1.Version",
HandlerType: (*VersionServer)(nil), HandlerType: (*VersionServer)(nil),
Methods: []grpc.MethodDesc{ Methods: []grpc.MethodDesc{
{ {
@ -446,20 +446,20 @@ func init() {
} }
var fileDescriptorVersion = []byte{ var fileDescriptorVersion = []byte{
// 225 bytes of a gzipped FileDescriptorProto // 230 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x72, 0x4e, 0xcf, 0x2c, 0xc9, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x72, 0x4e, 0xcf, 0x2c, 0xc9,
0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xce, 0xcf, 0x2b, 0x49, 0xcc, 0xcc, 0x4b, 0x2d, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xce, 0xcf, 0x2b, 0x49, 0xcc, 0xcc, 0x4b, 0x2d,
0x4a, 0x41, 0x66, 0x26, 0x16, 0x64, 0xea, 0x17, 0xa7, 0x16, 0x95, 0x65, 0x26, 0xa7, 0x16, 0xeb, 0x4a, 0x41, 0x66, 0x26, 0x16, 0x64, 0xea, 0x17, 0xa7, 0x16, 0x95, 0x65, 0x26, 0xa7, 0x16, 0xeb,
0x97, 0xa5, 0x16, 0x15, 0x67, 0xe6, 0xe7, 0xc1, 0x68, 0xbd, 0x82, 0xa2, 0xfc, 0x92, 0x7c, 0x21, 0x97, 0xa5, 0x16, 0x15, 0x67, 0xe6, 0xe7, 0xc1, 0x68, 0xbd, 0x82, 0xa2, 0xfc, 0x92, 0x7c, 0x21,
0x5e, 0x84, 0x72, 0xbd, 0x32, 0x43, 0x29, 0xe9, 0xf4, 0xfc, 0xfc, 0xf4, 0x9c, 0x54, 0x7d, 0xb0, 0x39, 0x84, 0x72, 0x3d, 0x98, 0x52, 0x3d, 0x98, 0x92, 0x32, 0x43, 0x29, 0xe9, 0xf4, 0xfc, 0xfc,
0x64, 0x52, 0x69, 0x9a, 0x7e, 0x6a, 0x6e, 0x41, 0x49, 0x25, 0x44, 0xad, 0x94, 0x48, 0x7a, 0x7e, 0xf4, 0x9c, 0x54, 0x7d, 0xb0, 0xea, 0xa4, 0xd2, 0x34, 0xfd, 0xd4, 0xdc, 0x82, 0x92, 0x4a, 0x88,
0x7a, 0x3e, 0x98, 0xa9, 0x0f, 0x62, 0x41, 0x44, 0x95, 0xdc, 0xb9, 0xf8, 0xc3, 0x20, 0x46, 0x06, 0x66, 0x29, 0x91, 0xf4, 0xfc, 0xf4, 0x7c, 0x30, 0x53, 0x1f, 0xc4, 0x82, 0x88, 0x2a, 0xb9, 0x73,
0xa5, 0x16, 0x17, 0xe4, 0xe7, 0x15, 0xa7, 0x0a, 0x49, 0x70, 0xb1, 0x43, 0x6d, 0x91, 0x60, 0x54, 0xf1, 0x87, 0x41, 0x0c, 0x08, 0x4a, 0x2d, 0x2e, 0xc8, 0xcf, 0x2b, 0x4e, 0x15, 0x92, 0xe0, 0x62,
0x60, 0xd4, 0xe0, 0x0c, 0x82, 0x71, 0x85, 0xa4, 0xb8, 0x38, 0x8a, 0x52, 0xcb, 0x32, 0xc1, 0x52, 0x87, 0x9a, 0x29, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0x19, 0x04, 0xe3, 0x0a, 0x49, 0x71, 0x71, 0x14,
0x4c, 0x60, 0x29, 0x38, 0xdf, 0xc8, 0x87, 0x8b, 0x1d, 0x6a, 0x90, 0x90, 0x23, 0x82, 0x29, 0xa6, 0xa5, 0x96, 0x65, 0x82, 0xa5, 0x98, 0xc0, 0x52, 0x70, 0xbe, 0x51, 0x2c, 0x17, 0x3b, 0xd4, 0x20,
0x07, 0x71, 0x92, 0x1e, 0xcc, 0x49, 0x7a, 0xae, 0x20, 0x27, 0x49, 0xc9, 0xe9, 0xa1, 0xb8, 0x5c, 0xa1, 0x20, 0x04, 0x53, 0x4c, 0x0f, 0xe2, 0x24, 0x3d, 0x98, 0x93, 0xf4, 0x5c, 0x41, 0x4e, 0x92,
0x0f, 0xcd, 0x0d, 0x4e, 0x12, 0x27, 0x1e, 0xca, 0x31, 0xdc, 0x78, 0x28, 0xc7, 0xd0, 0xf0, 0x48, 0xd2, 0xd7, 0xc3, 0xef, 0x15, 0x3d, 0x34, 0x47, 0x39, 0x49, 0x9c, 0x78, 0x28, 0xc7, 0x70, 0xe3,
0x8e, 0xf1, 0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18, 0x1f, 0x3c, 0x92, 0x63, 0x4c, 0x62, 0xa1, 0x1c, 0x43, 0xc3, 0x23, 0x39, 0xc6, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c, 0x92, 0x63, 0x7c,
0x03, 0x9b, 0x64, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0xb4, 0x27, 0xa4, 0xd8, 0x40, 0x01, 0x00, 0xf0, 0x48, 0x8e, 0x31, 0x89, 0x0d, 0x6c, 0xb4, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0xf3, 0x53,
0x00, 0x3d, 0xea, 0x62, 0x01, 0x00, 0x00,
} }

2
api/services/version/version.proto
View File

@ -1,6 +1,6 @@
syntax = "proto3"; syntax = "proto3";
package containerd.v1; package containerd.services.version.v1;
import "google/protobuf/empty.proto"; import "google/protobuf/empty.proto";
import "gogoproto/gogo.proto"; import "gogoproto/gogo.proto";

363
api/types/event/container.pb.go
View File

@ -21,7 +21,7 @@
ContainerDelete ContainerDelete
ContentDelete ContentDelete
Envelope Envelope
ImagePut ImageUpdate
ImageDelete ImageDelete
NamespaceCreate NamespaceCreate
NamespaceUpdate NamespaceUpdate
@ -63,15 +63,26 @@ var _ = math.Inf
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
type ContainerCreate struct { type ContainerCreate struct {
ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
Image string `protobuf:"bytes,2,opt,name=image,proto3" json:"image,omitempty"` Image string `protobuf:"bytes,2,opt,name=image,proto3" json:"image,omitempty"`
Runtime string `protobuf:"bytes,3,opt,name=runtime,proto3" json:"runtime,omitempty"` Runtime *ContainerCreate_Runtime `protobuf:"bytes,3,opt,name=runtime" json:"runtime,omitempty"`
} }
func (m *ContainerCreate) Reset() { *m = ContainerCreate{} } func (m *ContainerCreate) Reset() { *m = ContainerCreate{} }
func (*ContainerCreate) ProtoMessage() {} func (*ContainerCreate) ProtoMessage() {}
func (*ContainerCreate) Descriptor() ([]byte, []int) { return fileDescriptorContainer, []int{0} } func (*ContainerCreate) Descriptor() ([]byte, []int) { return fileDescriptorContainer, []int{0} }
type ContainerCreate_Runtime struct {
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
Options map[string]string `protobuf:"bytes,2,rep,name=options" json:"options,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (m *ContainerCreate_Runtime) Reset() { *m = ContainerCreate_Runtime{} }
func (*ContainerCreate_Runtime) ProtoMessage() {}
func (*ContainerCreate_Runtime) Descriptor() ([]byte, []int) {
return fileDescriptorContainer, []int{0, 0}
}
type ContainerUpdate struct { type ContainerUpdate struct {
ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
Image string `protobuf:"bytes,2,opt,name=image,proto3" json:"image,omitempty"` Image string `protobuf:"bytes,2,opt,name=image,proto3" json:"image,omitempty"`
@ -93,6 +104,7 @@ func (*ContainerDelete) Descriptor() ([]byte, []int) { return fileDescriptorCont
func init() { func init() {
proto.RegisterType((*ContainerCreate)(nil), "containerd.v1.types.ContainerCreate") proto.RegisterType((*ContainerCreate)(nil), "containerd.v1.types.ContainerCreate")
proto.RegisterType((*ContainerCreate_Runtime)(nil), "containerd.v1.types.ContainerCreate.Runtime")
proto.RegisterType((*ContainerUpdate)(nil), "containerd.v1.types.ContainerUpdate") proto.RegisterType((*ContainerUpdate)(nil), "containerd.v1.types.ContainerUpdate")
proto.RegisterType((*ContainerDelete)(nil), "containerd.v1.types.ContainerDelete") proto.RegisterType((*ContainerDelete)(nil), "containerd.v1.types.ContainerDelete")
} }
@ -123,11 +135,56 @@ func (m *ContainerCreate) MarshalTo(dAtA []byte) (int, error) {
i = encodeVarintContainer(dAtA, i, uint64(len(m.Image))) i = encodeVarintContainer(dAtA, i, uint64(len(m.Image)))
i += copy(dAtA[i:], m.Image) i += copy(dAtA[i:], m.Image)
} }
if len(m.Runtime) > 0 { if m.Runtime != nil {
dAtA[i] = 0x1a dAtA[i] = 0x1a
i++ i++
i = encodeVarintContainer(dAtA, i, uint64(len(m.Runtime))) i = encodeVarintContainer(dAtA, i, uint64(m.Runtime.Size()))
i += copy(dAtA[i:], m.Runtime) n1, err := m.Runtime.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n1
}
return i, nil
}
func (m *ContainerCreate_Runtime) 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 *ContainerCreate_Runtime) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.Name) > 0 {
dAtA[i] = 0xa
i++
i = encodeVarintContainer(dAtA, i, uint64(len(m.Name)))
i += copy(dAtA[i:], m.Name)
}
if len(m.Options) > 0 {
for k, _ := range m.Options {
dAtA[i] = 0x12
i++
v := m.Options[k]
mapSize := 1 + len(k) + sovContainer(uint64(len(k))) + 1 + len(v) + sovContainer(uint64(len(v)))
i = encodeVarintContainer(dAtA, i, uint64(mapSize))
dAtA[i] = 0xa
i++
i = encodeVarintContainer(dAtA, i, uint64(len(k)))
i += copy(dAtA[i:], k)
dAtA[i] = 0x12
i++
i = encodeVarintContainer(dAtA, i, uint64(len(v)))
i += copy(dAtA[i:], v)
}
} }
return i, nil return i, nil
} }
@ -247,10 +304,28 @@ func (m *ContainerCreate) Size() (n int) {
if l > 0 { if l > 0 {
n += 1 + l + sovContainer(uint64(l)) n += 1 + l + sovContainer(uint64(l))
} }
l = len(m.Runtime) if m.Runtime != nil {
l = m.Runtime.Size()
n += 1 + l + sovContainer(uint64(l))
}
return n
}
func (m *ContainerCreate_Runtime) Size() (n int) {
var l int
_ = l
l = len(m.Name)
if l > 0 { if l > 0 {
n += 1 + l + sovContainer(uint64(l)) n += 1 + l + sovContainer(uint64(l))
} }
if len(m.Options) > 0 {
for k, v := range m.Options {
_ = k
_ = v
mapEntrySize := 1 + len(k) + sovContainer(uint64(len(k))) + 1 + len(v) + sovContainer(uint64(len(v)))
n += mapEntrySize + 1 + sovContainer(uint64(mapEntrySize))
}
}
return n return n
} }
@ -310,7 +385,28 @@ func (this *ContainerCreate) String() string {
s := strings.Join([]string{`&ContainerCreate{`, s := strings.Join([]string{`&ContainerCreate{`,
`ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`,
`Image:` + fmt.Sprintf("%v", this.Image) + `,`, `Image:` + fmt.Sprintf("%v", this.Image) + `,`,
`Runtime:` + fmt.Sprintf("%v", this.Runtime) + `,`, `Runtime:` + strings.Replace(fmt.Sprintf("%v", this.Runtime), "ContainerCreate_Runtime", "ContainerCreate_Runtime", 1) + `,`,
`}`,
}, "")
return s
}
func (this *ContainerCreate_Runtime) String() string {
if this == nil {
return "nil"
}
keysForOptions := make([]string, 0, len(this.Options))
for k, _ := range this.Options {
keysForOptions = append(keysForOptions, k)
}
github_com_gogo_protobuf_sortkeys.Strings(keysForOptions)
mapStringForOptions := "map[string]string{"
for _, k := range keysForOptions {
mapStringForOptions += fmt.Sprintf("%v: %v,", k, this.Options[k])
}
mapStringForOptions += "}"
s := strings.Join([]string{`&ContainerCreate_Runtime{`,
`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
`Options:` + mapStringForOptions + `,`,
`}`, `}`,
}, "") }, "")
return s return s
@ -447,6 +543,89 @@ func (m *ContainerCreate) Unmarshal(dAtA []byte) error {
if wireType != 2 { if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Runtime", wireType) return fmt.Errorf("proto: wrong wireType = %d for field Runtime", wireType)
} }
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowContainer
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthContainer
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Runtime == nil {
m.Runtime = &ContainerCreate_Runtime{}
}
if err := m.Runtime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipContainer(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthContainer
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *ContainerCreate_Runtime) 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 ErrIntOverflowContainer
}
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: Runtime: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Runtime: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
}
var stringLen uint64 var stringLen uint64
for shift := uint(0); ; shift += 7 { for shift := uint(0); ; shift += 7 {
if shift >= 64 { if shift >= 64 {
@ -470,7 +649,123 @@ func (m *ContainerCreate) Unmarshal(dAtA []byte) error {
if postIndex > l { if postIndex > l {
return io.ErrUnexpectedEOF return io.ErrUnexpectedEOF
} }
m.Runtime = string(dAtA[iNdEx:postIndex]) m.Name = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowContainer
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthContainer
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
var keykey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowContainer
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
keykey |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
var stringLenmapkey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowContainer
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLenmapkey |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLenmapkey := int(stringLenmapkey)
if intStringLenmapkey < 0 {
return ErrInvalidLengthContainer
}
postStringIndexmapkey := iNdEx + intStringLenmapkey
if postStringIndexmapkey > l {
return io.ErrUnexpectedEOF
}
mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
iNdEx = postStringIndexmapkey
if m.Options == nil {
m.Options = make(map[string]string)
}
if iNdEx < postIndex {
var valuekey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowContainer
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
valuekey |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
var stringLenmapvalue uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowContainer
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLenmapvalue |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLenmapvalue := int(stringLenmapvalue)
if intStringLenmapvalue < 0 {
return ErrInvalidLengthContainer
}
postStringIndexmapvalue := iNdEx + intStringLenmapvalue
if postStringIndexmapvalue > l {
return io.ErrUnexpectedEOF
}
mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
iNdEx = postStringIndexmapvalue
m.Options[mapkey] = mapvalue
} else {
var mapvalue string
m.Options[mapkey] = mapvalue
}
iNdEx = postIndex iNdEx = postIndex
default: default:
iNdEx = preIndex iNdEx = preIndex
@ -935,26 +1230,30 @@ func init() {
} }
var fileDescriptorContainer = []byte{ var fileDescriptorContainer = []byte{
// 322 bytes of a gzipped FileDescriptorProto // 387 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x91, 0xbf, 0x4e, 0xf3, 0x30, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x52, 0x4f, 0x6b, 0xe2, 0x40,
0x14, 0xc5, 0xeb, 0xe6, 0xfb, 0x82, 0x70, 0x90, 0x8a, 0x42, 0x07, 0xab, 0x43, 0x5a, 0x65, 0xea, 0x1c, 0x75, 0x12, 0x37, 0xb2, 0x13, 0xc1, 0x65, 0xd6, 0x43, 0xc8, 0x21, 0x8a, 0x27, 0x0f, 0xcb,
0xe4, 0x40, 0x59, 0x80, 0x09, 0xf5, 0x0f, 0xa2, 0x12, 0x53, 0x10, 0x33, 0x4a, 0x9b, 0x4b, 0xb0, 0x64, 0xd7, 0xbd, 0xac, 0x9e, 0x16, 0xff, 0x51, 0xa1, 0x50, 0x18, 0xe9, 0xb9, 0x44, 0x33, 0x4d,
0x48, 0xe3, 0xc8, 0x75, 0x2a, 0x75, 0x63, 0xe0, 0xe1, 0x3a, 0x32, 0x32, 0x55, 0xd4, 0x4f, 0x82, 0x43, 0x93, 0x4c, 0x48, 0x46, 0xc1, 0x5b, 0x0f, 0xfd, 0x3c, 0xfd, 0x1c, 0x1e, 0x7b, 0xe8, 0xa1,
0xe2, 0xb4, 0x69, 0x84, 0x98, 0x10, 0xdb, 0xbd, 0xbe, 0xbf, 0xa3, 0x73, 0x74, 0x8c, 0xaf, 0x23, 0x27, 0xa9, 0xf9, 0x24, 0x25, 0x93, 0x18, 0x43, 0x29, 0x05, 0x4b, 0x6f, 0xbf, 0xc9, 0x7b, 0xef,
0x26, 0x9f, 0xb3, 0x09, 0x9d, 0xf2, 0x99, 0x37, 0xe5, 0x89, 0x0c, 0x58, 0x02, 0x22, 0xac, 0x8e, 0xf7, 0x7b, 0xef, 0x11, 0xf8, 0xdf, 0x71, 0xf9, 0xcd, 0x6a, 0x81, 0x97, 0xcc, 0x37, 0x97, 0x2c,
0x41, 0xca, 0x3c, 0xb9, 0x4c, 0x61, 0xee, 0xc1, 0x02, 0x12, 0xb9, 0x3f, 0xd1, 0x54, 0x70, 0xc9, 0xe0, 0x96, 0x1b, 0xd0, 0xc8, 0x2e, 0x8f, 0x56, 0xe8, 0x9a, 0x7c, 0x13, 0xd2, 0xd8, 0xa4, 0x6b,
0xed, 0x93, 0x3d, 0x4b, 0x17, 0x67, 0x54, 0xa3, 0xad, 0x66, 0xc4, 0x23, 0xae, 0xef, 0x5e, 0x3e, 0x1a, 0xf0, 0x23, 0x84, 0xc3, 0x88, 0x71, 0x86, 0x7e, 0x1e, 0xb9, 0x78, 0xfd, 0x07, 0x0b, 0xaa,
0x15, 0xa8, 0x9b, 0xe1, 0xc6, 0x60, 0x07, 0x0f, 0x04, 0x04, 0x12, 0xec, 0x1e, 0x3e, 0x2a, 0xf5, 0xde, 0x74, 0x98, 0xc3, 0x04, 0x6e, 0xa6, 0x53, 0x46, 0xed, 0x3c, 0x49, 0xb0, 0x31, 0x3a, 0xb0,
0x8f, 0x2c, 0x24, 0xa8, 0x83, 0xba, 0x87, 0xfd, 0x86, 0x5a, 0xb7, 0xad, 0x12, 0x1d, 0x0f, 0x7d, 0x47, 0x11, 0xb5, 0x38, 0x45, 0x3d, 0x58, 0x2f, 0x16, 0x5c, 0xb9, 0xb6, 0x06, 0xda, 0xa0, 0xfb,
0xab, 0x84, 0xc6, 0xa1, 0xdd, 0xc4, 0xff, 0xd9, 0x2c, 0x88, 0x80, 0xd4, 0x73, 0xd8, 0x2f, 0x16, 0x7d, 0xd8, 0x48, 0x76, 0x2d, 0xb5, 0xa0, 0xce, 0xc6, 0x44, 0x2d, 0x48, 0x33, 0x1b, 0x35, 0xe1,
0x9b, 0xe0, 0x03, 0x91, 0x25, 0x92, 0xcd, 0x80, 0x18, 0xfa, 0x7d, 0xb7, 0xba, 0x6f, 0xf5, 0x8a, 0x37, 0xd7, 0xb7, 0x1c, 0xaa, 0x49, 0x29, 0x99, 0x64, 0x0f, 0x34, 0x85, 0xb5, 0x68, 0x15, 0x70,
0xef, 0x43, 0x1a, 0xfe, 0xad, 0xef, 0x2d, 0x36, 0xe3, 0x60, 0x02, 0xf1, 0x9c, 0x18, 0x1d, 0xa3, 0xd7, 0xa7, 0x9a, 0xdc, 0x06, 0x5d, 0xb5, 0xf7, 0x0b, 0xbf, 0x63, 0x0d, 0xbf, 0x31, 0x80, 0x49,
0x6b, 0xf5, 0x4e, 0xe9, 0x0f, 0x85, 0xd0, 0x6f, 0xfe, 0xf4, 0x4e, 0x4b, 0x46, 0x89, 0x14, 0x4b, 0xa6, 0x21, 0x07, 0xb1, 0xfe, 0x00, 0x60, 0x2d, 0xff, 0x88, 0x10, 0xac, 0x06, 0x96, 0x4f, 0x33,
0x7f, 0xab, 0xb7, 0x5d, 0x6c, 0x0a, 0xce, 0xe5, 0xd3, 0x9c, 0xfc, 0xd3, 0x69, 0xb0, 0x5a, 0xb7, 0x57, 0x44, 0xcc, 0x68, 0x0e, 0x6b, 0x2c, 0xe4, 0x2e, 0x0b, 0x62, 0x4d, 0x6a, 0xcb, 0x5d, 0xb5,
0x4d, 0x9f, 0x73, 0x79, 0x73, 0xef, 0x6f, 0x2f, 0xad, 0x4b, 0x6c, 0x55, 0xa4, 0xf6, 0x31, 0x36, 0xd7, 0x3f, 0xe5, 0x0e, 0xbe, 0xc8, 0xb4, 0x93, 0x80, 0x47, 0x1b, 0x72, 0xd8, 0xa4, 0x0f, 0x60,
0x5e, 0x60, 0x59, 0xa4, 0xf7, 0xf3, 0x31, 0x0f, 0xb9, 0x08, 0xe2, 0xac, 0x0c, 0xa9, 0x97, 0xab, 0xbd, 0x0c, 0xa0, 0x1f, 0x50, 0xbe, 0xa5, 0x9b, 0xfc, 0x6e, 0x3a, 0xa6, 0xa1, 0xd7, 0x96, 0xb7,
0xfa, 0x05, 0x72, 0x47, 0x95, 0x16, 0x86, 0x10, 0xc3, 0xef, 0x5a, 0xe8, 0x93, 0xd5, 0xc6, 0xa9, 0x2a, 0x42, 0x8b, 0xc7, 0x40, 0xfa, 0x07, 0x3a, 0xf7, 0xe5, 0x5a, 0x2f, 0x43, 0xfb, 0x6b, 0x6b,
0x7d, 0x6c, 0x9c, 0xda, 0xab, 0x72, 0xd0, 0x4a, 0x39, 0xe8, 0x5d, 0x39, 0xe8, 0x53, 0x39, 0x68, 0x3d, 0x83, 0x8a, 0x67, 0x2d, 0xa8, 0x17, 0x6b, 0xb2, 0x48, 0xfb, 0xfb, 0xe3, 0xb4, 0xd9, 0x7d,
0x62, 0xea, 0x5f, 0x3e, 0xff, 0x0a, 0x00, 0x00, 0xff, 0xff, 0x3f, 0xf2, 0x95, 0xd3, 0x54, 0x02, 0x7c, 0x2e, 0x24, 0x59, 0xc8, 0x5c, 0x8f, 0x3a, 0x50, 0x89, 0x18, 0xe3, 0xd7, 0xb1, 0x56, 0x15,
0x00, 0x00, 0x6e, 0x60, 0xb2, 0x6b, 0x29, 0x84, 0x31, 0x3e, 0x9d, 0x93, 0x1c, 0xd1, 0xfb, 0x50, 0x2d, 0x49,
0x4f, 0xaa, 0x61, 0x52, 0x6a, 0x61, 0x4c, 0x3d, 0xfa, 0xb9, 0x16, 0x86, 0xda, 0x76, 0x6f, 0x54,
0x9e, 0xf7, 0x46, 0xe5, 0x2e, 0x31, 0xc0, 0x36, 0x31, 0xc0, 0x63, 0x62, 0x80, 0x97, 0xc4, 0x00,
0x0b, 0x45, 0xfc, 0xc5, 0x7f, 0x5f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x47, 0x2f, 0xd1, 0x73, 0x34,
0x03, 0x00, 0x00,
} }

6
api/types/event/container.proto
View File

@ -7,7 +7,11 @@ import "gogoproto/gogo.proto";
message ContainerCreate { message ContainerCreate {
string container_id = 1; string container_id = 1;
string image = 2; string image = 2;
string runtime = 3; message Runtime {
string name = 1;
map<string, string> options = 2;
}
Runtime runtime = 3;
} }
message ContainerUpdate { message ContainerUpdate {

191
api/types/event/image.pb.go
View File

@ -10,6 +10,7 @@ import math "math"
import strings "strings" import strings "strings"
import reflect "reflect" import reflect "reflect"
import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
import io "io" import io "io"
@ -18,14 +19,14 @@ var _ = proto.Marshal
var _ = fmt.Errorf var _ = fmt.Errorf
var _ = math.Inf var _ = math.Inf
type ImagePut struct { type ImageUpdate struct {
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
Labels string `protobuf:"bytes,2,opt,name=labels,proto3" json:"labels,omitempty"` Labels map[string]string `protobuf:"bytes,2,rep,name=labels" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
} }
func (m *ImagePut) Reset() { *m = ImagePut{} } func (m *ImageUpdate) Reset() { *m = ImageUpdate{} }
func (*ImagePut) ProtoMessage() {} func (*ImageUpdate) ProtoMessage() {}
func (*ImagePut) Descriptor() ([]byte, []int) { return fileDescriptorImage, []int{0} } func (*ImageUpdate) Descriptor() ([]byte, []int) { return fileDescriptorImage, []int{0} }
type ImageDelete struct { type ImageDelete struct {
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
@ -36,10 +37,10 @@ func (*ImageDelete) ProtoMessage() {}
func (*ImageDelete) Descriptor() ([]byte, []int) { return fileDescriptorImage, []int{1} } func (*ImageDelete) Descriptor() ([]byte, []int) { return fileDescriptorImage, []int{1} }
func init() { func init() {
proto.RegisterType((*ImagePut)(nil), "containerd.v1.types.ImagePut") proto.RegisterType((*ImageUpdate)(nil), "containerd.v1.types.ImageUpdate")
proto.RegisterType((*ImageDelete)(nil), "containerd.v1.types.ImageDelete") proto.RegisterType((*ImageDelete)(nil), "containerd.v1.types.ImageDelete")
} }
func (m *ImagePut) Marshal() (dAtA []byte, err error) { func (m *ImageUpdate) 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)
@ -49,7 +50,7 @@ func (m *ImagePut) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil return dAtA[:n], nil
} }
func (m *ImagePut) MarshalTo(dAtA []byte) (int, error) { func (m *ImageUpdate) MarshalTo(dAtA []byte) (int, error) {
var i int var i int
_ = i _ = i
var l int var l int
@ -61,10 +62,21 @@ func (m *ImagePut) MarshalTo(dAtA []byte) (int, error) {
i += copy(dAtA[i:], m.Name) i += copy(dAtA[i:], m.Name)
} }
if len(m.Labels) > 0 { if len(m.Labels) > 0 {
dAtA[i] = 0x12 for k, _ := range m.Labels {
i++ dAtA[i] = 0x12
i = encodeVarintImage(dAtA, i, uint64(len(m.Labels))) i++
i += copy(dAtA[i:], m.Labels) v := m.Labels[k]
mapSize := 1 + len(k) + sovImage(uint64(len(k))) + 1 + len(v) + sovImage(uint64(len(v)))
i = encodeVarintImage(dAtA, i, uint64(mapSize))
dAtA[i] = 0xa
i++
i = encodeVarintImage(dAtA, i, uint64(len(k)))
i += copy(dAtA[i:], k)
dAtA[i] = 0x12
i++
i = encodeVarintImage(dAtA, i, uint64(len(v)))
i += copy(dAtA[i:], v)
}
} }
return i, nil return i, nil
} }
@ -120,16 +132,20 @@ func encodeVarintImage(dAtA []byte, offset int, v uint64) int {
dAtA[offset] = uint8(v) dAtA[offset] = uint8(v)
return offset + 1 return offset + 1
} }
func (m *ImagePut) Size() (n int) { func (m *ImageUpdate) Size() (n int) {
var l int var l int
_ = l _ = l
l = len(m.Name) l = len(m.Name)
if l > 0 { if l > 0 {
n += 1 + l + sovImage(uint64(l)) n += 1 + l + sovImage(uint64(l))
} }
l = len(m.Labels) if len(m.Labels) > 0 {
if l > 0 { for k, v := range m.Labels {
n += 1 + l + sovImage(uint64(l)) _ = k
_ = v
mapEntrySize := 1 + len(k) + sovImage(uint64(len(k))) + 1 + len(v) + sovImage(uint64(len(v)))
n += mapEntrySize + 1 + sovImage(uint64(mapEntrySize))
}
} }
return n return n
} }
@ -157,13 +173,23 @@ func sovImage(x uint64) (n int) {
func sozImage(x uint64) (n int) { func sozImage(x uint64) (n int) {
return sovImage(uint64((x << 1) ^ uint64((int64(x) >> 63)))) return sovImage(uint64((x << 1) ^ uint64((int64(x) >> 63))))
} }
func (this *ImagePut) String() string { func (this *ImageUpdate) String() string {
if this == nil { if this == nil {
return "nil" return "nil"
} }
s := strings.Join([]string{`&ImagePut{`, keysForLabels := make([]string, 0, len(this.Labels))
for k, _ := range this.Labels {
keysForLabels = append(keysForLabels, k)
}
github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
mapStringForLabels := "map[string]string{"
for _, k := range keysForLabels {
mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k])
}
mapStringForLabels += "}"
s := strings.Join([]string{`&ImageUpdate{`,
`Name:` + fmt.Sprintf("%v", this.Name) + `,`, `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
`Labels:` + fmt.Sprintf("%v", this.Labels) + `,`, `Labels:` + mapStringForLabels + `,`,
`}`, `}`,
}, "") }, "")
return s return s
@ -186,7 +212,7 @@ func valueToStringImage(v interface{}) string {
pv := reflect.Indirect(rv).Interface() pv := reflect.Indirect(rv).Interface()
return fmt.Sprintf("*%v", pv) return fmt.Sprintf("*%v", pv)
} }
func (m *ImagePut) Unmarshal(dAtA []byte) error { func (m *ImageUpdate) Unmarshal(dAtA []byte) error {
l := len(dAtA) l := len(dAtA)
iNdEx := 0 iNdEx := 0
for iNdEx < l { for iNdEx < l {
@ -209,10 +235,10 @@ func (m *ImagePut) 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: ImagePut: wiretype end group for non-group") return fmt.Errorf("proto: ImageUpdate: wiretype end group for non-group")
} }
if fieldNum <= 0 { if fieldNum <= 0 {
return fmt.Errorf("proto: ImagePut: illegal tag %d (wire type %d)", fieldNum, wire) return fmt.Errorf("proto: ImageUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
} }
switch fieldNum { switch fieldNum {
case 1: case 1:
@ -248,7 +274,7 @@ func (m *ImagePut) Unmarshal(dAtA []byte) error {
if wireType != 2 { if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
} }
var stringLen uint64 var msglen int
for shift := uint(0); ; shift += 7 { for shift := uint(0); ; shift += 7 {
if shift >= 64 { if shift >= 64 {
return ErrIntOverflowImage return ErrIntOverflowImage
@ -258,20 +284,107 @@ func (m *ImagePut) Unmarshal(dAtA []byte) error {
} }
b := dAtA[iNdEx] b := dAtA[iNdEx]
iNdEx++ iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift msglen |= (int(b) & 0x7F) << shift
if b < 0x80 { if b < 0x80 {
break break
} }
} }
intStringLen := int(stringLen) if msglen < 0 {
if intStringLen < 0 {
return ErrInvalidLengthImage return ErrInvalidLengthImage
} }
postIndex := iNdEx + intStringLen postIndex := iNdEx + msglen
if postIndex > l { if postIndex > l {
return io.ErrUnexpectedEOF return io.ErrUnexpectedEOF
} }
m.Labels = string(dAtA[iNdEx:postIndex]) var keykey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowImage
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
keykey |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
var stringLenmapkey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowImage
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLenmapkey |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLenmapkey := int(stringLenmapkey)
if intStringLenmapkey < 0 {
return ErrInvalidLengthImage
}
postStringIndexmapkey := iNdEx + intStringLenmapkey
if postStringIndexmapkey > l {
return io.ErrUnexpectedEOF
}
mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
iNdEx = postStringIndexmapkey
if m.Labels == nil {
m.Labels = make(map[string]string)
}
if iNdEx < postIndex {
var valuekey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowImage
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
valuekey |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
var stringLenmapvalue uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowImage
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLenmapvalue |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLenmapvalue := int(stringLenmapvalue)
if intStringLenmapvalue < 0 {
return ErrInvalidLengthImage
}
postStringIndexmapvalue := iNdEx + intStringLenmapvalue
if postStringIndexmapvalue > l {
return io.ErrUnexpectedEOF
}
mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
iNdEx = postStringIndexmapvalue
m.Labels[mapkey] = mapvalue
} else {
var mapvalue string
m.Labels[mapkey] = mapvalue
}
iNdEx = postIndex iNdEx = postIndex
default: default:
iNdEx = preIndex iNdEx = preIndex
@ -483,16 +596,20 @@ func init() {
} }
var fileDescriptorImage = []byte{ var fileDescriptorImage = []byte{
// 175 bytes of a gzipped FileDescriptorProto // 232 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xb2, 0x49, 0xcf, 0x2c, 0xc9, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xb2, 0x49, 0xcf, 0x2c, 0xc9,
0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xce, 0xcf, 0x2b, 0x49, 0xcc, 0xcc, 0x4b, 0x2d, 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, 0xa7, 0x96, 0xa5, 0x4a, 0x41, 0x66, 0x26, 0x16, 0x64, 0xea, 0x97, 0x54, 0x16, 0xa4, 0x16, 0xeb, 0xa7, 0x96, 0xa5,
0xe6, 0x95, 0xe8, 0x67, 0xe6, 0x26, 0xa6, 0xa7, 0xea, 0x15, 0x14, 0xe5, 0x97, 0xe4, 0x0b, 0x09, 0xe6, 0x95, 0xe8, 0x67, 0xe6, 0x26, 0xa6, 0xa7, 0xea, 0x15, 0x14, 0xe5, 0x97, 0xe4, 0x0b, 0x09,
0x23, 0xd4, 0xe9, 0x95, 0x19, 0xea, 0x81, 0x95, 0x29, 0x99, 0x71, 0x71, 0x78, 0x82, 0xd4, 0x04, 0x23, 0xd4, 0xe9, 0x95, 0x19, 0xea, 0x81, 0x95, 0x29, 0x2d, 0x62, 0xe4, 0xe2, 0xf6, 0x04, 0x29,
0x94, 0x96, 0x08, 0x09, 0x71, 0xb1, 0xe4, 0x25, 0xe6, 0xa6, 0x4a, 0x30, 0x2a, 0x30, 0x6a, 0x70, 0x0a, 0x2d, 0x48, 0x49, 0x2c, 0x49, 0x15, 0x12, 0xe2, 0x62, 0xc9, 0x4b, 0xcc, 0x4d, 0x95, 0x60,
0x06, 0x81, 0xd9, 0x42, 0x62, 0x5c, 0x6c, 0x39, 0x89, 0x49, 0xa9, 0x39, 0xc5, 0x12, 0x4c, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x0c, 0x02, 0xb3, 0x85, 0x5c, 0xb8, 0xd8, 0x72, 0x12, 0x93, 0x52, 0x73,
0x51, 0x28, 0x4f, 0x49, 0x91, 0x8b, 0x1b, 0xac, 0xcf, 0x25, 0x35, 0x27, 0xb5, 0x24, 0x15, 0x9b, 0x8a, 0x25, 0x98, 0x14, 0x98, 0x35, 0xb8, 0x8d, 0x74, 0xf4, 0xb0, 0x98, 0xa4, 0x87, 0x64, 0x8a,
0x56, 0x27, 0x89, 0x13, 0x0f, 0xe5, 0x18, 0x6e, 0x3c, 0x94, 0x63, 0x68, 0x78, 0x24, 0xc7, 0x78, 0x9e, 0x0f, 0x58, 0xb9, 0x6b, 0x5e, 0x49, 0x51, 0x65, 0x10, 0x54, 0xaf, 0x94, 0x25, 0x17, 0x37,
0xe2, 0x91, 0x1c, 0xe3, 0x85, 0x47, 0x72, 0x8c, 0x0f, 0x1e, 0xc9, 0x31, 0x26, 0xb1, 0x81, 0x1d, 0x92, 0xb0, 0x90, 0x00, 0x17, 0x73, 0x76, 0x6a, 0x25, 0xd4, 0x1e, 0x10, 0x53, 0x48, 0x84, 0x8b,
0x64, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0xfa, 0x87, 0x34, 0x3a, 0xd0, 0x00, 0x00, 0x00, 0xb5, 0x2c, 0x31, 0xa7, 0x34, 0x55, 0x82, 0x09, 0x2c, 0x06, 0xe1, 0x58, 0x31, 0x59, 0x30, 0x2a,
0x29, 0x42, 0xdd, 0xe8, 0x92, 0x9a, 0x93, 0x8a, 0xdd, 0x8d, 0x4e, 0x12, 0x27, 0x1e, 0xca, 0x31,
0xdc, 0x78, 0x28, 0xc7, 0xd0, 0xf0, 0x48, 0x8e, 0xf1, 0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4,
0x18, 0x1f, 0x3c, 0x92, 0x63, 0x4c, 0x62, 0x03, 0xfb, 0xde, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff,
0xa7, 0x64, 0x49, 0x13, 0x3d, 0x01, 0x00, 0x00,
} }

4
api/types/event/image.proto
View File

@ -2,9 +2,9 @@ syntax = "proto3";
package containerd.v1.types; package containerd.v1.types;
message ImagePut { message ImageUpdate {
string name = 1; string name = 1;
string labels = 2; map<string, string> labels = 2;
} }
message ImageDelete { message ImageDelete {

14
client.go
View File

@ -180,7 +180,9 @@ func WithNewReadonlyRootFS(id string, i Image) NewContainerOpts {
func WithRuntime(name string) NewContainerOpts { func WithRuntime(name string) NewContainerOpts {
return func(ctx context.Context, client *Client, c *containers.Container) error { return func(ctx context.Context, client *Client, c *containers.Container) error {
c.Runtime = name c.Runtime = &containers.Container_Runtime{
Name: name,
}
return nil return nil
} }
} }
@ -196,8 +198,10 @@ func WithImage(i Image) NewContainerOpts {
// the id must be unique within the namespace // the id must be unique within the namespace
func (c *Client) NewContainer(ctx context.Context, id string, opts ...NewContainerOpts) (Container, error) { func (c *Client) NewContainer(ctx context.Context, id string, opts ...NewContainerOpts) (Container, error) {
container := containers.Container{ container := containers.Container{
ID: id, ID: id,
Runtime: c.runtime, Runtime: &containers.Container_Runtime{
Name: c.runtime,
},
} }
for _, o := range opts { for _, o := range opts {
if err := o(ctx, c, &container); err != nil { if err := o(ctx, c, &container); err != nil {
@ -331,7 +335,7 @@ func (c *Client) Pull(ctx context.Context, ref string, opts ...RemoteOpts) (Imag
} }
is := c.ImageService() is := c.ImageService()
if err := is.Put(ctx, name, desc); err != nil { if err := is.Update(ctx, name, desc); err != nil {
return nil, err return nil, err
} }
i, err := is.Get(ctx, name) i, err := is.Get(ctx, name)
@ -448,7 +452,7 @@ func (c *Client) ContentStore() content.Store {
} }
func (c *Client) SnapshotService() snapshot.Snapshotter { func (c *Client) SnapshotService() snapshot.Snapshotter {
return snapshotservice.NewSnapshotterFromClient(snapshotapi.NewSnapshotClient(c.conn)) return snapshotservice.NewSnapshotterFromClient(snapshotapi.NewSnapshotsClient(c.conn))
} }
func (c *Client) TaskService() execution.TasksClient { func (c *Client) TaskService() execution.TasksClient {

3
client_test.go
View File

@ -27,7 +27,7 @@ var (
) )
func init() { func init() {
flag.StringVar(&address, "address", "/run/containerd/containerd.sock", "The address to the containerd socket for use in the tests") flag.StringVar(&address, "address", "/run/containerd-test/containerd.sock", "The address to the containerd socket for use in the tests")
flag.BoolVar(&noDaemon, "no-daemon", false, "Do not start a dedicated daemon for the tests") flag.BoolVar(&noDaemon, "no-daemon", false, "Do not start a dedicated daemon for the tests")
flag.Parse() flag.Parse()
} }
@ -59,6 +59,7 @@ func TestMain(m *testing.M) {
cmd = exec.Command("containerd", cmd = exec.Command("containerd",
"--root", defaultRoot, "--root", defaultRoot,
"--state", defaultState, "--state", defaultState,
"--address", address,
) )
cmd.Stderr = buf cmd.Stderr = buf
if err := cmd.Start(); err != nil { if err := cmd.Start(); err != nil {

2
cmd/containerd/main.go
View File

@ -323,7 +323,7 @@ func interceptor(ctx gocontext.Context,
// No need to change the context // No need to change the context
case versionapi.VersionServer: case versionapi.VersionServer:
ctx = log.WithModule(ctx, "version") ctx = log.WithModule(ctx, "version")
case snapshotapi.SnapshotServer: case snapshotapi.SnapshotsServer:
ctx = log.WithModule(ctx, "snapshot") ctx = log.WithModule(ctx, "snapshot")
case diffapi.DiffServer: case diffapi.DiffServer:
ctx = log.WithModule(ctx, "diff") ctx = log.WithModule(ctx, "diff")

6
cmd/ctr/events.go
View File

@ -23,7 +23,7 @@ var eventsCommand = cli.Command{
ctx, cancel := appContext(context) ctx, cancel := appContext(context)
defer cancel() defer cancel()
events, err := eventsClient.EventStream(ctx, &eventsapi.EventStreamRequest{}) events, err := eventsClient.Stream(ctx, &eventsapi.StreamEventsRequest{})
if err != nil { if err != nil {
return err return err
} }
@ -114,8 +114,8 @@ func getEventOutput(evt *event.Envelope) (string, error) {
return out, err return out, err
} }
out = "key=" + e.Key out = "key=" + e.Key
case "types.containerd.io/containerd.v1.types.event.ImagePut": case "types.containerd.io/containerd.v1.types.event.ImageUpdate":
e := &event.ImagePut{} e := &event.ImageUpdate{}
if err := proto.Unmarshal(evt.Event.Value, e); err != nil { if err := proto.Unmarshal(evt.Event.Value, e); err != nil {
return out, err return out, err
} }

18
cmd/ctr/utils.go
View File

@ -21,7 +21,6 @@ import (
namespacesapi "github.com/containerd/containerd/api/services/namespaces" namespacesapi "github.com/containerd/containerd/api/services/namespaces"
snapshotapi "github.com/containerd/containerd/api/services/snapshot" snapshotapi "github.com/containerd/containerd/api/services/snapshot"
versionservice "github.com/containerd/containerd/api/services/version" versionservice "github.com/containerd/containerd/api/services/version"
"github.com/containerd/containerd/api/types/task"
"github.com/containerd/containerd/content" "github.com/containerd/containerd/content"
"github.com/containerd/containerd/images" "github.com/containerd/containerd/images"
"github.com/containerd/containerd/namespaces" "github.com/containerd/containerd/namespaces"
@ -112,7 +111,7 @@ func getSnapshotter(context *cli.Context) (snapshot.Snapshotter, error) {
if err != nil { if err != nil {
return nil, err return nil, err
} }
return snapshotservice.NewSnapshotterFromClient(snapshotapi.NewSnapshotClient(conn)), nil return snapshotservice.NewSnapshotterFromClient(snapshotapi.NewSnapshotsClient(conn)), nil
} }
func getImageStore(clicontext *cli.Context) (images.Store, error) { func getImageStore(clicontext *cli.Context) (images.Store, error) {
@ -139,21 +138,6 @@ func getVersionService(context *cli.Context) (versionservice.VersionClient, erro
return versionservice.NewVersionClient(conn), nil return versionservice.NewVersionClient(conn), nil
} }
func waitContainer(events execution.Tasks_EventsClient, id string, pid uint32) (uint32, error) {
for {
e, err := events.Recv()
if err != nil {
return 255, err
}
if e.Type != task.Event_EXIT {
continue
}
if e.ID == id && e.Pid == pid {
return e.ExitStatus, nil
}
}
}
func forwardAllSignals(ctx gocontext.Context, task killer) chan os.Signal { func forwardAllSignals(ctx gocontext.Context, task killer) chan os.Signal {
sigc := make(chan os.Signal, 128) sigc := make(chan os.Signal, 128)
signal.Notify(sigc) signal.Notify(sigc)

1
cmd/dist/rootfs.go vendored
View File

@ -99,7 +99,6 @@ var rootfsPrepareCommand = cli.Command{
} }
snapshotter := client.SnapshotService() snapshotter := client.SnapshotService()
mounts, err := snapshotter.Prepare(ctx, target, dgst.String()) mounts, err := snapshotter.Prepare(ctx, target, dgst.String())
if err != nil { if err != nil {
return err return err

6
container.go
View File

@ -104,7 +104,7 @@ func (c *container) Image(ctx context.Context) (Image, error) {
}, nil }, nil
} }
type NewTaskOpts func(context.Context, *Client, *execution.CreateRequest) error type NewTaskOpts func(context.Context, *Client, *execution.CreateTaskRequest) error
func (c *container) NewTask(ctx context.Context, ioCreate IOCreation, opts ...NewTaskOpts) (Task, error) { func (c *container) NewTask(ctx context.Context, ioCreate IOCreation, opts ...NewTaskOpts) (Task, error) {
c.mu.Lock() c.mu.Lock()
@ -113,7 +113,7 @@ func (c *container) NewTask(ctx context.Context, ioCreate IOCreation, opts ...Ne
if err != nil { if err != nil {
return nil, err return nil, err
} }
request := &execution.CreateRequest{ request := &execution.CreateTaskRequest{
ContainerID: c.c.ID, ContainerID: c.c.ID,
Terminal: i.Terminal, Terminal: i.Terminal,
Stdin: i.Stdin, Stdin: i.Stdin,
@ -161,7 +161,7 @@ func (c *container) NewTask(ctx context.Context, ioCreate IOCreation, opts ...Ne
} }
func (c *container) loadTask(ctx context.Context, ioAttach IOAttach) (Task, error) { func (c *container) loadTask(ctx context.Context, ioAttach IOAttach) (Task, error) {
response, err := c.client.TaskService().Info(ctx, &execution.InfoRequest{ response, err := c.client.TaskService().Get(ctx, &execution.GetTaskRequest{
ContainerID: c.c.ID, ContainerID: c.c.ID,
}) })
if err != nil { if err != nil {

6
container_test.go
View File

@ -389,7 +389,7 @@ func TestContainerProcesses(t *testing.T) {
<-statusC <-statusC
} }
func TestContainerCloseStdin(t *testing.T) { func TestContainerCloseIO(t *testing.T) {
if testing.Short() { if testing.Short() {
t.Skip() t.Skip()
} }
@ -456,7 +456,7 @@ func TestContainerCloseStdin(t *testing.T) {
t.Error(err) t.Error(err)
} }
w.Close() w.Close()
if err := task.CloseStdin(ctx); err != nil { if err := task.CloseIO(ctx, WithStdinCloser); err != nil {
t.Error(err) t.Error(err)
} }
@ -576,7 +576,7 @@ func TestContainerAttach(t *testing.T) {
} }
w.Close() w.Close()
if err := task.CloseStdin(ctx); err != nil { if err := task.CloseIO(ctx, WithStdinCloser); err != nil {
t.Error(err) t.Error(err)
} }

2
container_unix.go
View File

@ -83,7 +83,7 @@ func WithCheckpoint(desc v1.Descriptor, rootfsID string) NewContainerOpts {
} }
func WithTaskCheckpoint(desc v1.Descriptor) NewTaskOpts { func WithTaskCheckpoint(desc v1.Descriptor) NewTaskOpts {
return func(ctx context.Context, c *Client, r *execution.CreateRequest) error { return func(ctx context.Context, c *Client, r *execution.CreateTaskRequest) error {
id := desc.Digest id := desc.Digest
index, err := decodeIndex(ctx, c.ContentStore(), id) index, err := decodeIndex(ctx, c.ContentStore(), id)
if err != nil { if err != nil {

27
containers/containers.go
View File

@ -1,7 +1,10 @@
package containers package containers
import ( import (
"bytes"
"context" "context"
"encoding/gob"
"errors"
"time" "time"
) )
@ -13,13 +16,35 @@ type Container struct {
ID string ID string
Labels map[string]string Labels map[string]string
Image string Image string
Runtime string Runtime RuntimeInfo
Spec []byte Spec []byte
RootFS string RootFS string
CreatedAt time.Time CreatedAt time.Time
UpdatedAt time.Time UpdatedAt time.Time
} }
type RuntimeInfo struct {
Name string
Options map[string]string
}
func (r RuntimeInfo) MarshalBinary() ([]byte, error) {
buf := bytes.NewBuffer(nil)
if err := gob.NewEncoder(buf).Encode(r); err != nil {
return nil, err
}
return buf.Bytes(), nil
}
func (r RuntimeInfo) UnmarshalBinary(data []byte) error {
buf := data
if len(buf) == 0 {
return errors.New("RuntimeInfo: no data")
}
reader := bytes.NewReader(buf)
return gob.NewDecoder(reader).Decode(&r)
}
type Store interface { type Store interface {
Get(ctx context.Context, id string) (Container, error) Get(ctx context.Context, id string) (Container, error)
List(ctx context.Context, filter string) ([]Container, error) List(ctx context.Context, filter string) ([]Container, error)

4
events/convert.go
View File

@ -52,8 +52,8 @@ func convertToAny(evt Event) (*protobuf.Any, error) {
case event.SnapshotRemove: case event.SnapshotRemove:
url = getUrl("SnapshotRemove") url = getUrl("SnapshotRemove")
pb = &v pb = &v
case event.ImagePut: case event.ImageUpdate:
url = getUrl("ImagePut") url = getUrl("ImageUpdate")
pb = &v pb = &v
case event.ImageDelete: case event.ImageDelete:
url = getUrl("ImageDelete") url = getUrl("ImageDelete")

2
images/image.go
View File

@ -18,7 +18,7 @@ type Image struct {
} }
type Store interface { type Store interface {
Put(ctx context.Context, name string, desc ocispec.Descriptor) error Update(ctx context.Context, name string, desc ocispec.Descriptor) error
Get(ctx context.Context, name string) (Image, error) Get(ctx context.Context, name string) (Image, error)
List(ctx context.Context) ([]Image, error) List(ctx context.Context) ([]Image, error)
Delete(ctx context.Context, name string) error Delete(ctx context.Context, name string) error

25
linux/shim/init.go
View File

@ -254,19 +254,24 @@ func (p *initProcess) Stdin() io.Closer {
func (p *initProcess) Checkpoint(context context.Context, r *shimapi.CheckpointRequest) error { func (p *initProcess) Checkpoint(context context.Context, r *shimapi.CheckpointRequest) error {
var actions []runc.CheckpointAction var actions []runc.CheckpointAction
if !r.Exit { /*
actions = append(actions, runc.LeaveRunning) if !r.Exit {
} actions = append(actions, runc.LeaveRunning)
}
*/
work := filepath.Join(p.bundle, "work") work := filepath.Join(p.bundle, "work")
defer os.RemoveAll(work) defer os.RemoveAll(work)
// TODO: convert options into runc flags or a better format for criu
if err := p.runc.Checkpoint(context, p.id, &runc.CheckpointOpts{ if err := p.runc.Checkpoint(context, p.id, &runc.CheckpointOpts{
WorkDir: work, WorkDir: work,
ImagePath: r.CheckpointPath, ImagePath: r.Path,
AllowOpenTCP: r.AllowTcp, /*
AllowExternalUnixSockets: r.AllowUnixSockets, AllowOpenTCP: r.AllowTcp,
AllowTerminal: r.AllowTerminal, AllowExternalUnixSockets: r.AllowUnixSockets,
FileLocks: r.FileLocks, AllowTerminal: r.AllowTerminal,
EmptyNamespaces: r.EmptyNamespaces, FileLocks: r.FileLocks,
EmptyNamespaces: r.EmptyNamespaces,
*/
}, actions...); err != nil { }, actions...); err != nil {
dumpLog := filepath.Join(p.bundle, "criu-dump.log") dumpLog := filepath.Join(p.bundle, "criu-dump.log")
if cerr := copyFile(dumpLog, filepath.Join(work, "dump.log")); cerr != nil { if cerr := copyFile(dumpLog, filepath.Join(work, "dump.log")); cerr != nil {

21
linux/task.go
View File

@ -165,20 +165,15 @@ func (t *Task) CloseStdin(ctx context.Context, pid uint32) error {
return err return err
} }
func (t *Task) Checkpoint(ctx context.Context, opts plugin.CheckpointOpts) error { func (t *Task) Checkpoint(ctx context.Context, path string, options map[string]string) error {
_, err := t.shim.Checkpoint(ctx, &shim.CheckpointRequest{ r := &shim.CheckpointRequest{
Exit: opts.Exit, Path: path,
AllowTcp: opts.AllowTCP, Options: options,
AllowUnixSockets: opts.AllowUnixSockets,
AllowTerminal: opts.AllowTerminal,
FileLocks: opts.FileLocks,
EmptyNamespaces: opts.EmptyNamespaces,
CheckpointPath: opts.Path,
})
if err != nil {
err = errors.New(grpc.ErrorDesc(err))
} }
return err if _, err := t.shim.Checkpoint(ctx, r); err != nil {
return errors.New(grpc.ErrorDesc(err))
}
return nil
} }
func (t *Task) DeleteProcess(ctx context.Context, pid uint32) (*plugin.Exit, error) { func (t *Task) DeleteProcess(ctx context.Context, pid uint32) (*plugin.Exit, error) {

10
metadata/containers.go
View File

@ -146,7 +146,9 @@ func readContainer(container *containers.Container, bkt *bolt.Bucket) error {
case string(bucketKeyImage): case string(bucketKeyImage):
container.Image = string(v) container.Image = string(v)
case string(bucketKeyRuntime): case string(bucketKeyRuntime):
container.Runtime = string(v) if err := container.Runtime.UnmarshalBinary(v); err != nil {
return err
}
case string(bucketKeySpec): case string(bucketKeySpec):
container.Spec = make([]byte, len(v)) container.Spec = make([]byte, len(v))
copy(container.Spec, v) copy(container.Spec, v)
@ -187,9 +189,13 @@ func writeContainer(container *containers.Container, bkt *bolt.Bucket) error {
if err != nil { if err != nil {
return err return err
} }
runtime, err := container.Runtime.MarshalBinary()
if err != nil {
return err
}
for _, v := range [][2][]byte{ for _, v := range [][2][]byte{
{bucketKeyImage, []byte(container.Image)}, {bucketKeyImage, []byte(container.Image)},
{bucketKeyRuntime, []byte(container.Runtime)}, {bucketKeyRuntime, runtime},
{bucketKeySpec, container.Spec}, {bucketKeySpec, container.Spec},
{bucketKeyRootFS, []byte(container.RootFS)}, {bucketKeyRootFS, []byte(container.RootFS)},
{bucketKeyCreatedAt, createdAt}, {bucketKeyCreatedAt, createdAt},

2
metadata/images.go
View File

@ -46,7 +46,7 @@ func (s *imageStore) Get(ctx context.Context, name string) (images.Image, error)
return image, nil return image, nil
} }
func (s *imageStore) Put(ctx context.Context, name string, desc ocispec.Descriptor) error { func (s *imageStore) Update(ctx context.Context, name string, desc ocispec.Descriptor) error {
namespace, err := namespaces.NamespaceRequired(ctx) namespace, err := namespaces.NamespaceRequired(ctx)
if err != nil { if err != nil {
return err return err

12
plugin/container.go
View File

@ -32,21 +32,11 @@ type Task interface {
// CloseStdin closes the processes stdin // CloseStdin closes the processes stdin
CloseStdin(context.Context, uint32) error CloseStdin(context.Context, uint32) error
// Checkpoint checkpoints a container to an image with live system data // Checkpoint checkpoints a container to an image with live system data
Checkpoint(context.Context, CheckpointOpts) error Checkpoint(context.Context, string, map[string]string) error
// DeleteProcess deletes a specific exec process via the pid // DeleteProcess deletes a specific exec process via the pid
DeleteProcess(context.Context, uint32) (*Exit, error) DeleteProcess(context.Context, uint32) (*Exit, error)
} }
type CheckpointOpts struct {
Exit bool
AllowTCP bool
AllowUnixSockets bool
AllowTerminal bool
FileLocks bool
EmptyNamespaces []string
Path string
}
type ExecOpts struct { type ExecOpts struct {
Spec []byte Spec []byte
IO IO IO IO

34
process.go
View File

@ -3,10 +3,10 @@ package containerd
import ( import (
"context" "context"
"encoding/json" "encoding/json"
"fmt"
"syscall" "syscall"
"github.com/containerd/containerd/api/services/execution" "github.com/containerd/containerd/api/services/execution"
taskapi "github.com/containerd/containerd/api/types/task"
protobuf "github.com/gogo/protobuf/types" protobuf "github.com/gogo/protobuf/types"
specs "github.com/opencontainers/runtime-spec/specs-go" specs "github.com/opencontainers/runtime-spec/specs-go"
) )
@ -38,7 +38,7 @@ func (p *process) Start(ctx context.Context) error {
if err != nil { if err != nil {
return err return err
} }
request := &execution.ExecRequest{ request := &execution.ExecProcessRequest{
ContainerID: p.task.containerID, ContainerID: p.task.containerID,
Terminal: p.io.Terminal, Terminal: p.io.Terminal,
Stdin: p.io.Stdin, Stdin: p.io.Stdin,
@ -70,30 +70,18 @@ func (p *process) Kill(ctx context.Context, s syscall.Signal) error {
} }
func (p *process) Wait(ctx context.Context) (uint32, error) { func (p *process) Wait(ctx context.Context) (uint32, error) {
events, err := p.task.client.TaskService().Events(ctx, &execution.EventsRequest{}) return 255, fmt.Errorf("not implemented")
if err != nil {
return UnknownExitStatus, err
}
<-p.pidSync
for {
e, err := events.Recv()
if err != nil {
return UnknownExitStatus, err
}
if e.Type != taskapi.Event_EXIT {
continue
}
if e.ID == p.task.containerID && e.Pid == p.pid {
return e.ExitStatus, nil
}
}
} }
func (p *process) CloseStdin(ctx context.Context) error { func (p *process) CloseIO(ctx context.Context, opts ...IOCloserOpts) error {
_, err := p.task.client.TaskService().CloseStdin(ctx, &execution.CloseStdinRequest{ r := &execution.CloseIORequest{
ContainerID: p.task.containerID, ContainerID: p.task.containerID,
Pid: p.pid, Pid: p.pid,
}) }
for _, o := range opts {
o(r)
}
_, err := p.task.client.TaskService().CloseIO(ctx, r)
return err return err
} }
@ -102,7 +90,7 @@ func (p *process) IO() *IO {
} }
func (p *process) Resize(ctx context.Context, w, h uint32) error { func (p *process) Resize(ctx context.Context, w, h uint32) error {
_, err := p.task.client.TaskService().Pty(ctx, &execution.PtyRequest{ _, err := p.task.client.TaskService().ResizePty(ctx, &execution.ResizePtyRequest{
ContainerID: p.task.containerID, ContainerID: p.task.containerID,
Width: w, Width: w,
Height: h, Height: h,

26
services/containers/helpers.go
View File

@ -22,10 +22,13 @@ func containersToProto(containers []containers.Container) []api.Container {
func containerToProto(container *containers.Container) api.Container { func containerToProto(container *containers.Container) api.Container {
return api.Container{ return api.Container{
ID: container.ID, ID: container.ID,
Labels: container.Labels, Labels: container.Labels,
Image: container.Image, Image: container.Image,
Runtime: container.Runtime, Runtime: &api.Container_Runtime{
Name: container.Runtime.Name,
Options: container.Runtime.Options,
},
Spec: &types.Any{ Spec: &types.Any{
TypeUrl: specs.Version, TypeUrl: specs.Version,
Value: container.Spec, Value: container.Spec,
@ -36,12 +39,15 @@ func containerToProto(container *containers.Container) api.Container {
func containerFromProto(containerpb *api.Container) containers.Container { func containerFromProto(containerpb *api.Container) containers.Container {
return containers.Container{ return containers.Container{
ID: containerpb.ID, ID: containerpb.ID,
Labels: containerpb.Labels, Labels: containerpb.Labels,
Image: containerpb.Image, Image: containerpb.Image,
Runtime: containerpb.Runtime, Runtime: containers.RuntimeInfo{
Spec: containerpb.Spec.Value, Name: containerpb.Runtime.Name,
RootFS: containerpb.RootFS, Options: containerpb.Runtime.Options,
},
Spec: containerpb.Spec.Value,
RootFS: containerpb.RootFS,
} }
} }

5
services/containers/service.go
View File

@ -96,7 +96,10 @@ func (s *Service) Create(ctx context.Context, req *api.CreateContainerRequest) (
if err := s.emit(ctx, "/containers/create", event.ContainerCreate{ if err := s.emit(ctx, "/containers/create", event.ContainerCreate{
ContainerID: resp.Container.ID, ContainerID: resp.Container.ID,
Image: resp.Container.Image, Image: resp.Container.Image,
Runtime: resp.Container.Runtime, Runtime: &event.ContainerCreate_Runtime{
Name: resp.Container.Runtime.Name,
Options: resp.Container.Runtime.Options,
},
}); err != nil { }); err != nil {
return &resp, err return &resp, err
} }

6
services/content/reader.go
View File

@ -26,7 +26,7 @@ func (rr *remoteReader) Read(p []byte) (n int, err error) {
p = p[n:] p = p[n:]
for len(p) > 0 { for len(p) > 0 {
var resp *contentapi.ReadResponse var resp *contentapi.ReadContentResponse
// fill our buffer up until we can fill p. // fill our buffer up until we can fill p.
resp, err = rr.client.Recv() resp, err = rr.client.Recv()
if err != nil { if err != nil {
@ -56,7 +56,7 @@ type remoteReaderAt struct {
} }
func (ra *remoteReaderAt) ReadAt(p []byte, off int64) (n int, err error) { func (ra *remoteReaderAt) ReadAt(p []byte, off int64) (n int, err error) {
rr := &contentapi.ReadRequest{ rr := &contentapi.ReadContentRequest{
Digest: ra.digest, Digest: ra.digest,
Offset: off, Offset: off,
Size_: int64(len(p)), Size_: int64(len(p)),
@ -67,7 +67,7 @@ func (ra *remoteReaderAt) ReadAt(p []byte, off int64) (n int, err error) {
} }
for len(p) > 0 { for len(p) > 0 {
var resp *contentapi.ReadResponse var resp *contentapi.ReadContentResponse
// fill our buffer up until we can fill p. // fill our buffer up until we can fill p.
resp, err = rc.Recv() resp, err = rc.Recv()
if err != nil { if err != nil {

16
services/content/service.go
View File

@ -137,7 +137,7 @@ func (s *Service) Delete(ctx context.Context, req *api.DeleteContentRequest) (*e
return &empty.Empty{}, nil return &empty.Empty{}, nil
} }
func (s *Service) Read(req *api.ReadRequest, session api.Content_ReadServer) error { func (s *Service) Read(req *api.ReadContentRequest, session api.Content_ReadServer) error {
if err := req.Digest.Validate(); err != nil { if err := req.Digest.Validate(); err != nil {
return grpc.Errorf(codes.InvalidArgument, "%v: %v", req.Digest, err) return grpc.Errorf(codes.InvalidArgument, "%v: %v", req.Digest, err)
} }
@ -193,7 +193,7 @@ func (s *Service) Read(req *api.ReadRequest, session api.Content_ReadServer) err
return nil return nil
} }
// readResponseWriter is a writer that places the output into ReadResponse messages. // readResponseWriter is a writer that places the output into ReadContentRequest messages.
// //
// This allows io.CopyBuffer to do the heavy lifting of chunking the responses // This allows io.CopyBuffer to do the heavy lifting of chunking the responses
// into the buffer size. // into the buffer size.
@ -203,7 +203,7 @@ type readResponseWriter struct {
} }
func (rw *readResponseWriter) Write(p []byte) (n int, err error) { func (rw *readResponseWriter) Write(p []byte) (n int, err error) {
if err := rw.session.Send(&api.ReadResponse{ if err := rw.session.Send(&api.ReadContentResponse{
Offset: rw.offset, Offset: rw.offset,
Data: p, Data: p,
}); err != nil { }); err != nil {
@ -215,9 +215,9 @@ func (rw *readResponseWriter) Write(p []byte) (n int, err error) {
} }
func (s *Service) Status(ctx context.Context, req *api.StatusRequest) (*api.StatusResponse, error) { func (s *Service) Status(ctx context.Context, req *api.StatusRequest) (*api.StatusResponse, error) {
statuses, err := s.store.Status(ctx, req.Regexp) statuses, err := s.store.Status(ctx, req.Filter)
if err != nil { if err != nil {
return nil, serverErrorToGRPC(err, req.Regexp) return nil, serverErrorToGRPC(err, req.Filter)
} }
var resp api.StatusResponse var resp api.StatusResponse
@ -238,14 +238,14 @@ func (s *Service) Status(ctx context.Context, req *api.StatusRequest) (*api.Stat
func (s *Service) Write(session api.Content_WriteServer) (err error) { func (s *Service) Write(session api.Content_WriteServer) (err error) {
var ( var (
ctx = session.Context() ctx = session.Context()
msg api.WriteResponse msg api.WriteContentResponse
req *api.WriteRequest req *api.WriteContentRequest
ref string ref string
total int64 total int64
expected digest.Digest expected digest.Digest
) )
defer func(msg *api.WriteResponse) { defer func(msg *api.WriteContentResponse) {
// pump through the last message if no error was encountered // pump through the last message if no error was encountered
if err != nil { if err != nil {
if grpc.Code(err) != codes.AlreadyExists { if grpc.Code(err) != codes.AlreadyExists {

8
services/content/store.go
View File

@ -75,7 +75,7 @@ func (rs *remoteStore) Delete(ctx context.Context, dgst digest.Digest) error {
} }
func (rs *remoteStore) Reader(ctx context.Context, dgst digest.Digest) (io.ReadCloser, error) { func (rs *remoteStore) Reader(ctx context.Context, dgst digest.Digest) (io.ReadCloser, error) {
client, err := rs.client.Read(ctx, &contentapi.ReadRequest{Digest: dgst}) client, err := rs.client.Read(ctx, &contentapi.ReadContentRequest{Digest: dgst})
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -93,9 +93,9 @@ func (rs *remoteStore) ReaderAt(ctx context.Context, dgst digest.Digest) (io.Rea
}, nil }, nil
} }
func (rs *remoteStore) Status(ctx context.Context, re string) ([]content.Status, error) { func (rs *remoteStore) Status(ctx context.Context, filter string) ([]content.Status, error) {
resp, err := rs.client.Status(ctx, &contentapi.StatusRequest{ resp, err := rs.client.Status(ctx, &contentapi.StatusRequest{
Regexp: re, Filter: filter,
}) })
if err != nil { if err != nil {
return nil, rewriteGRPCError(err) return nil, rewriteGRPCError(err)
@ -146,7 +146,7 @@ func (rs *remoteStore) negotiate(ctx context.Context, ref string, size int64, ex
return nil, 0, err return nil, 0, err
} }
if err := wrclient.Send(&contentapi.WriteRequest{ if err := wrclient.Send(&contentapi.WriteContentRequest{
Action: contentapi.WriteActionStat, Action: contentapi.WriteActionStat,
Ref: ref, Ref: ref,
Total: size, Total: size,

8
services/content/writer.go
View File

@ -17,7 +17,7 @@ type remoteWriter struct {
} }
// send performs a synchronous req-resp cycle on the client. // send performs a synchronous req-resp cycle on the client.
func (rw *remoteWriter) send(req *contentapi.WriteRequest) (*contentapi.WriteResponse, error) { func (rw *remoteWriter) send(req *contentapi.WriteContentRequest) (*contentapi.WriteContentResponse, error) {
if err := rw.client.Send(req); err != nil { if err := rw.client.Send(req); err != nil {
return nil, err return nil, err
} }
@ -35,7 +35,7 @@ func (rw *remoteWriter) send(req *contentapi.WriteRequest) (*contentapi.WriteRes
} }
func (rw *remoteWriter) Status() (content.Status, error) { func (rw *remoteWriter) Status() (content.Status, error) {
resp, err := rw.send(&contentapi.WriteRequest{ resp, err := rw.send(&contentapi.WriteContentRequest{
Action: contentapi.WriteActionStat, Action: contentapi.WriteActionStat,
}) })
if err != nil { if err != nil {
@ -57,7 +57,7 @@ func (rw *remoteWriter) Digest() digest.Digest {
func (rw *remoteWriter) Write(p []byte) (n int, err error) { func (rw *remoteWriter) Write(p []byte) (n int, err error) {
offset := rw.offset offset := rw.offset
resp, err := rw.send(&contentapi.WriteRequest{ resp, err := rw.send(&contentapi.WriteContentRequest{
Action: contentapi.WriteActionWrite, Action: contentapi.WriteActionWrite,
Offset: offset, Offset: offset,
Data: p, Data: p,
@ -79,7 +79,7 @@ func (rw *remoteWriter) Write(p []byte) (n int, err error) {
} }
func (rw *remoteWriter) Commit(size int64, expected digest.Digest) error { func (rw *remoteWriter) Commit(size int64, expected digest.Digest) error {
resp, err := rw.send(&contentapi.WriteRequest{ resp, err := rw.send(&contentapi.WriteContentRequest{
Action: contentapi.WriteActionCommit, Action: contentapi.WriteActionCommit,
Total: size, Total: size,
Offset: rw.offset, Offset: rw.offset,

2
services/events/service.go
View File

@ -35,7 +35,7 @@ func (s *Service) Register(server *grpc.Server) error {
return nil return nil
} }
func (s *Service) EventStream(req *api.EventStreamRequest, srv api.Events_EventStreamServer) error { func (s *Service) Stream(req *api.StreamEventsRequest, srv api.Events_StreamServer) error {
clientID := fmt.Sprintf("%d", time.Now().UnixNano()) clientID := fmt.Sprintf("%d", time.Now().UnixNano())
for { for {
e := <-s.emitter.Events(srv.Context(), clientID) e := <-s.emitter.Events(srv.Context(), clientID)

89
services/execution/collector.go
View File

@ -1,89 +0,0 @@
package execution
import (
"sync"
"github.com/containerd/containerd/plugin"
"golang.org/x/net/context"
)
func newCollector(ctx context.Context, runtimes map[string]plugin.Runtime) (*collector, error) {
c := &collector{
context: ctx,
ch: make(chan *plugin.Event, 2048),
eventClients: make(map[*eventClient]struct{}),
}
for _, r := range runtimes {
if err := c.collect(r); err != nil {
return nil, err
}
}
// run the publisher
go c.publisher()
// run a goroutine that waits for the context to be done
// and closes the channel after all writes have finished
go c.waitDone()
return c, nil
}
type eventClient struct {
eCh chan error
w *grpcEventWriter
}
type collector struct {
mu sync.Mutex
wg sync.WaitGroup
context context.Context
ch chan *plugin.Event
eventClients map[*eventClient]struct{}
}
// collect collects events from the provided runtime
func (c *collector) collect(r plugin.Runtime) error {
c.wg.Add(1)
go func() {
defer c.wg.Done()
for e := range r.Events(c.context) {
c.ch <- e
}
}()
return nil
}
func (c *collector) forward(w *grpcEventWriter) error {
client := &eventClient{
w: w,
eCh: make(chan error, 1),
}
c.mu.Lock()
c.eventClients[client] = struct{}{}
c.mu.Unlock()
err := <-client.eCh
c.mu.Lock()
delete(c.eventClients, client)
c.mu.Unlock()
return err
}
func (c *collector) publisher() {
for e := range c.ch {
c.mu.Lock()
for client := range c.eventClients {
if err := client.w.Write(e); err != nil {
client.eCh <- err
}
}
c.mu.Unlock()
}
}
// waitDone waits for the context to finish, waits for all the goroutines to finish
// collecting grpc events from the shim, and closes the output channel
func (c *collector) waitDone() {
<-c.context.Done()
c.wg.Wait()
close(c.ch)
}

117
services/execution/service.go
View File

@ -67,26 +67,20 @@ func New(ic *plugin.InitContext) (interface{}, error) {
r := rr.(plugin.Runtime) r := rr.(plugin.Runtime)
runtimes[r.ID()] = r runtimes[r.ID()] = r
} }
c, err := newCollector(ic.Context, runtimes)
if err != nil {
return nil, err
}
e := events.GetPoster(ic.Context) e := events.GetPoster(ic.Context)
return &Service{ return &Service{
runtimes: runtimes, runtimes: runtimes,
db: m.(*bolt.DB), db: m.(*bolt.DB),
collector: c, store: ct.(content.Store),
store: ct.(content.Store), emitter: e,
emitter: e,
}, nil }, nil
} }
type Service struct { type Service struct {
runtimes map[string]plugin.Runtime runtimes map[string]plugin.Runtime
db *bolt.DB db *bolt.DB
collector *collector store content.Store
store content.Store emitter events.Poster
emitter events.Poster
} }
func (s *Service) Register(server *grpc.Server) error { func (s *Service) Register(server *grpc.Server) error {
@ -94,7 +88,7 @@ func (s *Service) Register(server *grpc.Server) error {
return nil return nil
} }
func (s *Service) Create(ctx context.Context, r *api.CreateRequest) (*api.CreateResponse, error) { func (s *Service) Create(ctx context.Context, r *api.CreateTaskRequest) (*api.CreateTaskResponse, error) {
var ( var (
checkpointPath string checkpointPath string
err error err error
@ -152,7 +146,7 @@ func (s *Service) Create(ctx context.Context, r *api.CreateRequest) (*api.Create
Options: m.Options, Options: m.Options,
}) })
} }
runtime, err := s.getRuntime(container.Runtime) runtime, err := s.getRuntime(container.Runtime.Name)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -171,13 +165,13 @@ func (s *Service) Create(ctx context.Context, r *api.CreateRequest) (*api.Create
return nil, err return nil, err
} }
return &api.CreateResponse{ return &api.CreateTaskResponse{
ContainerID: r.ContainerID, ContainerID: r.ContainerID,
Pid: state.Pid, Pid: state.Pid,
}, nil }, nil
} }
func (s *Service) Start(ctx context.Context, r *api.StartRequest) (*google_protobuf.Empty, error) { func (s *Service) Start(ctx context.Context, r *api.StartTaskRequest) (*google_protobuf.Empty, error) {
t, err := s.getTask(ctx, r.ContainerID) t, err := s.getTask(ctx, r.ContainerID)
if err != nil { if err != nil {
return nil, err return nil, err
@ -195,7 +189,7 @@ func (s *Service) Start(ctx context.Context, r *api.StartRequest) (*google_proto
return empty, nil return empty, nil
} }
func (s *Service) Delete(ctx context.Context, r *api.DeleteRequest) (*api.DeleteResponse, error) { func (s *Service) Delete(ctx context.Context, r *api.DeleteTaskRequest) (*api.DeleteResponse, error) {
t, err := s.getTask(ctx, r.ContainerID) t, err := s.getTask(ctx, r.ContainerID)
if err != nil { if err != nil {
return nil, err return nil, err
@ -271,7 +265,7 @@ func taskFromContainerd(ctx context.Context, c plugin.Task) (*task.Task, error)
}, nil }, nil
} }
func (s *Service) Info(ctx context.Context, r *api.InfoRequest) (*api.InfoResponse, error) { func (s *Service) Get(ctx context.Context, r *api.GetTaskRequest) (*api.GetTaskResponse, error) {
task, err := s.getTask(ctx, r.ContainerID) task, err := s.getTask(ctx, r.ContainerID)
if err != nil { if err != nil {
return nil, err return nil, err
@ -280,13 +274,13 @@ func (s *Service) Info(ctx context.Context, r *api.InfoRequest) (*api.InfoRespon
if err != nil { if err != nil {
return nil, err return nil, err
} }
return &api.InfoResponse{ return &api.GetTaskResponse{
Task: t, Task: t,
}, nil }, nil
} }
func (s *Service) List(ctx context.Context, r *api.ListRequest) (*api.ListResponse, error) { func (s *Service) List(ctx context.Context, r *api.ListTasksRequest) (*api.ListTasksResponse, error) {
resp := &api.ListResponse{} resp := &api.ListTasksResponse{}
for _, r := range s.runtimes { for _, r := range s.runtimes {
tasks, err := r.Tasks(ctx) tasks, err := r.Tasks(ctx)
if err != nil { if err != nil {
@ -303,7 +297,7 @@ func (s *Service) List(ctx context.Context, r *api.ListRequest) (*api.ListRespon
return resp, nil return resp, nil
} }
func (s *Service) Pause(ctx context.Context, r *api.PauseRequest) (*google_protobuf.Empty, error) { func (s *Service) Pause(ctx context.Context, r *api.PauseTaskRequest) (*google_protobuf.Empty, error) {
t, err := s.getTask(ctx, r.ContainerID) t, err := s.getTask(ctx, r.ContainerID)
if err != nil { if err != nil {
return nil, err return nil, err
@ -315,7 +309,7 @@ func (s *Service) Pause(ctx context.Context, r *api.PauseRequest) (*google_proto
return empty, nil return empty, nil
} }
func (s *Service) Resume(ctx context.Context, r *api.ResumeRequest) (*google_protobuf.Empty, error) { func (s *Service) Resume(ctx context.Context, r *api.ResumeTaskRequest) (*google_protobuf.Empty, error) {
t, err := s.getTask(ctx, r.ContainerID) t, err := s.getTask(ctx, r.ContainerID)
if err != nil { if err != nil {
return nil, err return nil, err
@ -348,7 +342,7 @@ func (s *Service) Kill(ctx context.Context, r *api.KillRequest) (*google_protobu
return empty, nil return empty, nil
} }
func (s *Service) Processes(ctx context.Context, r *api.ProcessesRequest) (*api.ProcessesResponse, error) { func (s *Service) ListProcesses(ctx context.Context, r *api.ListProcessesRequest) (*api.ListProcessesResponse, error) {
t, err := s.getTask(ctx, r.ContainerID) t, err := s.getTask(ctx, r.ContainerID)
if err != nil { if err != nil {
return nil, err return nil, err
@ -365,22 +359,12 @@ func (s *Service) Processes(ctx context.Context, r *api.ProcessesRequest) (*api.
Pid: pid, Pid: pid,
}) })
} }
return &api.ListProcessesResponse{
resp := &api.ProcessesResponse{
Processes: ps, Processes: ps,
} }, nil
return resp, nil
} }
func (s *Service) Events(r *api.EventsRequest, server api.Tasks_EventsServer) error { func (s *Service) Exec(ctx context.Context, r *api.ExecProcessRequest) (*api.ExecProcessResponse, error) {
w := &grpcEventWriter{
server: server,
}
return s.collector.forward(w)
}
func (s *Service) Exec(ctx context.Context, r *api.ExecRequest) (*api.ExecResponse, error) {
t, err := s.getTask(ctx, r.ContainerID) t, err := s.getTask(ctx, r.ContainerID)
if err != nil { if err != nil {
return nil, err return nil, err
@ -401,12 +385,12 @@ func (s *Service) Exec(ctx context.Context, r *api.ExecRequest) (*api.ExecRespon
if err != nil { if err != nil {
return nil, err return nil, err
} }
return &api.ExecResponse{ return &api.ExecProcessResponse{
Pid: state.Pid, Pid: state.Pid,
}, nil }, nil
} }
func (s *Service) Pty(ctx context.Context, r *api.PtyRequest) (*google_protobuf.Empty, error) { func (s *Service) ResizePty(ctx context.Context, r *api.ResizePtyRequest) (*google_protobuf.Empty, error) {
t, err := s.getTask(ctx, r.ContainerID) t, err := s.getTask(ctx, r.ContainerID)
if err != nil { if err != nil {
return nil, err return nil, err
@ -420,18 +404,20 @@ func (s *Service) Pty(ctx context.Context, r *api.PtyRequest) (*google_protobuf.
return empty, nil return empty, nil
} }
func (s *Service) CloseStdin(ctx context.Context, r *api.CloseStdinRequest) (*google_protobuf.Empty, error) { func (s *Service) CloseIO(ctx context.Context, r *api.CloseIORequest) (*google_protobuf.Empty, error) {
t, err := s.getTask(ctx, r.ContainerID) t, err := s.getTask(ctx, r.ContainerID)
if err != nil { if err != nil {
return nil, err return nil, err
} }
if err := t.CloseStdin(ctx, r.Pid); err != nil { if r.Stdin {
return nil, err if err := t.CloseStdin(ctx, r.Pid); err != nil {
return nil, err
}
} }
return empty, nil return empty, nil
} }
func (s *Service) Checkpoint(ctx context.Context, r *api.CheckpointRequest) (*api.CheckpointResponse, error) { func (s *Service) Checkpoint(ctx context.Context, r *api.CheckpointTaskRequest) (*api.CheckpointTaskResponse, error) {
t, err := s.getTask(ctx, r.ContainerID) t, err := s.getTask(ctx, r.ContainerID)
if err != nil { if err != nil {
return nil, err return nil, err
@ -441,16 +427,7 @@ func (s *Service) Checkpoint(ctx context.Context, r *api.CheckpointRequest) (*ap
return nil, err return nil, err
} }
defer os.RemoveAll(image) defer os.RemoveAll(image)
if err := t.Checkpoint(ctx, plugin.CheckpointOpts{ if err := t.Checkpoint(ctx, image, r.Options); err != nil {
Exit: r.Exit,
AllowTCP: r.AllowTcp,
AllowTerminal: r.AllowTerminal,
AllowUnixSockets: r.AllowUnixSockets,
FileLocks: r.FileLocks,
// ParentImage: r.ParentImage,
EmptyNamespaces: r.EmptyNamespaces,
Path: image,
}); err != nil {
return nil, err return nil, err
} }
// write checkpoint to the content store // write checkpoint to the content store
@ -469,7 +446,7 @@ func (s *Service) Checkpoint(ctx context.Context, r *api.CheckpointRequest) (*ap
if err != nil { if err != nil {
return nil, err return nil, err
} }
return &api.CheckpointResponse{ return &api.CheckpointTaskResponse{
Descriptors: []*descriptor.Descriptor{ Descriptors: []*descriptor.Descriptor{
cp, cp,
specD, specD,
@ -523,31 +500,3 @@ func (s *Service) emit(ctx context.Context, topic string, evt interface{}) error
return nil return nil
} }
type grpcEventWriter struct {
server api.Tasks_EventsServer
}
func (g *grpcEventWriter) Write(e *plugin.Event) error {
var t task.Event_EventType
switch e.Type {
case plugin.ExitEvent:
t = task.Event_EXIT
case plugin.ExecAddEvent:
t = task.Event_EXEC_ADDED
case plugin.PausedEvent:
t = task.Event_PAUSED
case plugin.CreateEvent:
t = task.Event_CREATE
case plugin.StartEvent:
t = task.Event_START
case plugin.OOMEvent:
t = task.Event_OOM
}
return g.server.Send(&task.Event{
Type: t,
ID: e.ID,
Pid: e.Pid,
ExitStatus: e.ExitStatus,
})
}

10
services/images/client.go
View File

@ -18,10 +18,10 @@ func NewStoreFromClient(client imagesapi.ImagesClient) images.Store {
} }
} }
func (s *remoteStore) Put(ctx context.Context, name string, desc ocispec.Descriptor) error { func (s *remoteStore) Update(ctx context.Context, name string, desc ocispec.Descriptor) error {
// TODO(stevvooe): Consider that the remote may want to augment and return // TODO(stevvooe): Consider that the remote may want to augment and return
// a modified image. // a modified image.
_, err := s.client.Put(ctx, &imagesapi.PutRequest{ _, err := s.client.Update(ctx, &imagesapi.UpdateImageRequest{
Image: imagesapi.Image{ Image: imagesapi.Image{
Name: name, Name: name,
Target: descToProto(&desc), Target: descToProto(&desc),
@ -32,7 +32,7 @@ func (s *remoteStore) Put(ctx context.Context, name string, desc ocispec.Descrip
} }
func (s *remoteStore) Get(ctx context.Context, name string) (images.Image, error) { func (s *remoteStore) Get(ctx context.Context, name string) (images.Image, error) {
resp, err := s.client.Get(ctx, &imagesapi.GetRequest{ resp, err := s.client.Get(ctx, &imagesapi.GetImageRequest{
Name: name, Name: name,
}) })
if err != nil { if err != nil {
@ -43,7 +43,7 @@ func (s *remoteStore) Get(ctx context.Context, name string) (images.Image, error
} }
func (s *remoteStore) List(ctx context.Context) ([]images.Image, error) { func (s *remoteStore) List(ctx context.Context) ([]images.Image, error) {
resp, err := s.client.List(ctx, &imagesapi.ListRequest{}) resp, err := s.client.List(ctx, &imagesapi.ListImagesRequest{})
if err != nil { if err != nil {
return nil, rewriteGRPCError(err) return nil, rewriteGRPCError(err)
} }
@ -52,7 +52,7 @@ func (s *remoteStore) List(ctx context.Context) ([]images.Image, error) {
} }
func (s *remoteStore) Delete(ctx context.Context, name string) error { func (s *remoteStore) Delete(ctx context.Context, name string) error {
_, err := s.client.Delete(ctx, &imagesapi.DeleteRequest{ _, err := s.client.Delete(ctx, &imagesapi.DeleteImageRequest{
Name: name, Name: name,
}) })

29
services/images/service.go
View File

@ -48,8 +48,8 @@ func (s *Service) Register(server *grpc.Server) error {
return nil return nil
} }
func (s *Service) Get(ctx context.Context, req *imagesapi.GetRequest) (*imagesapi.GetResponse, error) { func (s *Service) Get(ctx context.Context, req *imagesapi.GetImageRequest) (*imagesapi.GetImageResponse, error) {
var resp imagesapi.GetResponse var resp imagesapi.GetImageResponse
return &resp, s.withStoreView(ctx, func(ctx context.Context, store images.Store) error { return &resp, s.withStoreView(ctx, func(ctx context.Context, store images.Store) error {
image, err := store.Get(ctx, req.Name) image, err := store.Get(ctx, req.Name)
@ -62,25 +62,28 @@ func (s *Service) Get(ctx context.Context, req *imagesapi.GetRequest) (*imagesap
}) })
} }
func (s *Service) Put(ctx context.Context, req *imagesapi.PutRequest) (*empty.Empty, error) { func (s *Service) Update(ctx context.Context, req *imagesapi.UpdateImageRequest) (*imagesapi.UpdateImageResponse, error) {
if err := s.withStoreUpdate(ctx, func(ctx context.Context, store images.Store) error { if err := s.withStoreUpdate(ctx, func(ctx context.Context, store images.Store) error {
return mapGRPCError(store.Put(ctx, req.Image.Name, descFromProto(&req.Image.Target)), req.Image.Name) return mapGRPCError(store.Update(ctx, req.Image.Name, descFromProto(&req.Image.Target)), req.Image.Name)
}); err != nil { }); err != nil {
return &empty.Empty{}, err return nil, err
} }
if err := s.emit(ctx, "/images/put", event.ImagePut{ if err := s.emit(ctx, "/images/update", event.ImageUpdate{
Name: req.Image.Name, Name: req.Image.Name,
Labels: req.Image.Labels, Labels: req.Image.Labels,
}); err != nil { }); err != nil {
return &empty.Empty{}, err return nil, err
} }
return &empty.Empty{}, nil // TODO: get image back out to return
return &imagesapi.UpdateImageResponse{
//Image: nil,
}, nil
} }
func (s *Service) List(ctx context.Context, _ *imagesapi.ListRequest) (*imagesapi.ListResponse, error) { func (s *Service) List(ctx context.Context, _ *imagesapi.ListImagesRequest) (*imagesapi.ListImagesResponse, error) {
var resp imagesapi.ListResponse var resp imagesapi.ListImagesResponse
return &resp, s.withStoreView(ctx, func(ctx context.Context, store images.Store) error { return &resp, s.withStoreView(ctx, func(ctx context.Context, store images.Store) error {
images, err := store.List(ctx) images, err := store.List(ctx)
@ -93,17 +96,17 @@ func (s *Service) List(ctx context.Context, _ *imagesapi.ListRequest) (*imagesap
}) })
} }
func (s *Service) Delete(ctx context.Context, req *imagesapi.DeleteRequest) (*empty.Empty, error) { func (s *Service) Delete(ctx context.Context, req *imagesapi.DeleteImageRequest) (*empty.Empty, error) {
if err := s.withStoreUpdate(ctx, func(ctx context.Context, store images.Store) error { if err := s.withStoreUpdate(ctx, func(ctx context.Context, store images.Store) error {
return mapGRPCError(store.Delete(ctx, req.Name), req.Name) return mapGRPCError(store.Delete(ctx, req.Name), req.Name)
}); err != nil { }); err != nil {
return &empty.Empty{}, err return nil, err
} }
if err := s.emit(ctx, "/images/delete", event.ImageDelete{ if err := s.emit(ctx, "/images/delete", event.ImageDelete{
Name: req.Name, Name: req.Name,
}); err != nil { }); err != nil {
return &empty.Empty{}, err return nil, err
} }
return &empty.Empty{}, nil return &empty.Empty{}, nil

29
services/snapshot/client.go
View File

@ -9,6 +9,7 @@ import (
"google.golang.org/grpc/codes" "google.golang.org/grpc/codes"
snapshotapi "github.com/containerd/containerd/api/services/snapshot" snapshotapi "github.com/containerd/containerd/api/services/snapshot"
mountapi "github.com/containerd/containerd/api/types/mount"
"github.com/containerd/containerd/mount" "github.com/containerd/containerd/mount"
"github.com/containerd/containerd/snapshot" "github.com/containerd/containerd/snapshot"
"github.com/pkg/errors" "github.com/pkg/errors"
@ -16,18 +17,18 @@ import (
// NewSnapshotterFromClient returns a new Snapshotter which communicates // NewSnapshotterFromClient returns a new Snapshotter which communicates
// over a GRPC connection. // over a GRPC connection.
func NewSnapshotterFromClient(client snapshotapi.SnapshotClient) snapshot.Snapshotter { func NewSnapshotterFromClient(client snapshotapi.SnapshotsClient) snapshot.Snapshotter {
return &remoteSnapshotter{ return &remoteSnapshotter{
client: client, client: client,
} }
} }
type remoteSnapshotter struct { type remoteSnapshotter struct {
client snapshotapi.SnapshotClient client snapshotapi.SnapshotsClient
} }
func (r *remoteSnapshotter) Stat(ctx context.Context, key string) (snapshot.Info, error) { func (r *remoteSnapshotter) Stat(ctx context.Context, key string) (snapshot.Info, error) {
resp, err := r.client.Stat(ctx, &snapshotapi.StatRequest{Key: key}) resp, err := r.client.Stat(ctx, &snapshotapi.StatSnapshotRequest{Key: key})
if err != nil { if err != nil {
return snapshot.Info{}, rewriteGRPCError(err) return snapshot.Info{}, rewriteGRPCError(err)
} }
@ -47,27 +48,27 @@ func (r *remoteSnapshotter) Mounts(ctx context.Context, key string) ([]mount.Mou
if err != nil { if err != nil {
return nil, rewriteGRPCError(err) return nil, rewriteGRPCError(err)
} }
return toMounts(resp), nil return toMounts(resp.Mounts), nil
} }
func (r *remoteSnapshotter) Prepare(ctx context.Context, key, parent string) ([]mount.Mount, error) { func (r *remoteSnapshotter) Prepare(ctx context.Context, key, parent string) ([]mount.Mount, error) {
resp, err := r.client.Prepare(ctx, &snapshotapi.PrepareRequest{Key: key, Parent: parent}) resp, err := r.client.Prepare(ctx, &snapshotapi.PrepareSnapshotRequest{Key: key, Parent: parent})
if err != nil { if err != nil {
return nil, rewriteGRPCError(err) return nil, rewriteGRPCError(err)
} }
return toMounts(resp), nil return toMounts(resp.Mounts), nil
} }
func (r *remoteSnapshotter) View(ctx context.Context, key, parent string) ([]mount.Mount, error) { func (r *remoteSnapshotter) View(ctx context.Context, key, parent string) ([]mount.Mount, error) {
resp, err := r.client.View(ctx, &snapshotapi.PrepareRequest{Key: key, Parent: parent}) resp, err := r.client.View(ctx, &snapshotapi.ViewSnapshotRequest{Key: key, Parent: parent})
if err != nil { if err != nil {
return nil, rewriteGRPCError(err) return nil, rewriteGRPCError(err)
} }
return toMounts(resp), nil return toMounts(resp.Mounts), nil
} }
func (r *remoteSnapshotter) Commit(ctx context.Context, name, key string) error { func (r *remoteSnapshotter) Commit(ctx context.Context, name, key string) error {
_, err := r.client.Commit(ctx, &snapshotapi.CommitRequest{ _, err := r.client.Commit(ctx, &snapshotapi.CommitSnapshotRequest{
Name: name, Name: name,
Key: key, Key: key,
}) })
@ -75,12 +76,12 @@ func (r *remoteSnapshotter) Commit(ctx context.Context, name, key string) error
} }
func (r *remoteSnapshotter) Remove(ctx context.Context, key string) error { func (r *remoteSnapshotter) Remove(ctx context.Context, key string) error {
_, err := r.client.Remove(ctx, &snapshotapi.RemoveRequest{Key: key}) _, err := r.client.Remove(ctx, &snapshotapi.RemoveSnapshotRequest{Key: key})
return rewriteGRPCError(err) return rewriteGRPCError(err)
} }
func (r *remoteSnapshotter) Walk(ctx context.Context, fn func(context.Context, snapshot.Info) error) error { func (r *remoteSnapshotter) Walk(ctx context.Context, fn func(context.Context, snapshot.Info) error) error {
sc, err := r.client.List(ctx, &snapshotapi.ListRequest{}) sc, err := r.client.List(ctx, &snapshotapi.ListSnapshotsRequest{})
if err != nil { if err != nil {
rewriteGRPCError(err) rewriteGRPCError(err)
} }
@ -145,9 +146,9 @@ func toUsage(resp *snapshotapi.UsageResponse) snapshot.Usage {
} }
} }
func toMounts(resp *snapshotapi.MountsResponse) []mount.Mount { func toMounts(mm []*mountapi.Mount) []mount.Mount {
mounts := make([]mount.Mount, len(resp.Mounts)) mounts := make([]mount.Mount, len(mm))
for i, m := range resp.Mounts { for i, m := range mm {
mounts[i] = mount.Mount{ mounts[i] = mount.Mount{
Type: m.Type, Type: m.Type,
Source: m.Source, Source: m.Source,

42
services/snapshot/service.go
View File

@ -50,11 +50,11 @@ func newService(snapshotter snapshot.Snapshotter, evts events.Poster) (*service,
} }
func (s *service) Register(gs *grpc.Server) error { func (s *service) Register(gs *grpc.Server) error {
snapshotapi.RegisterSnapshotServer(gs, s) snapshotapi.RegisterSnapshotsServer(gs, s)
return nil return nil
} }
func (s *service) Prepare(ctx context.Context, pr *snapshotapi.PrepareRequest) (*snapshotapi.MountsResponse, error) { func (s *service) Prepare(ctx context.Context, pr *snapshotapi.PrepareSnapshotRequest) (*snapshotapi.PrepareSnapshotResponse, error) {
log.G(ctx).WithField("parent", pr.Parent).WithField("key", pr.Key).Debugf("Preparing snapshot") log.G(ctx).WithField("parent", pr.Parent).WithField("key", pr.Key).Debugf("Preparing snapshot")
// TODO: Apply namespace // TODO: Apply namespace
// TODO: Lookup snapshot id from metadata store // TODO: Lookup snapshot id from metadata store
@ -69,11 +69,12 @@ func (s *service) Prepare(ctx context.Context, pr *snapshotapi.PrepareRequest) (
}); err != nil { }); err != nil {
return nil, err return nil, err
} }
return &snapshotapi.PrepareSnapshotResponse{
return fromMounts(mounts), nil Mounts: fromMounts(mounts),
}, nil
} }
func (s *service) View(ctx context.Context, pr *snapshotapi.PrepareRequest) (*snapshotapi.MountsResponse, error) { func (s *service) View(ctx context.Context, pr *snapshotapi.ViewSnapshotRequest) (*snapshotapi.ViewSnapshotResponse, error) {
log.G(ctx).WithField("parent", pr.Parent).WithField("key", pr.Key).Debugf("Preparing view snapshot") log.G(ctx).WithField("parent", pr.Parent).WithField("key", pr.Key).Debugf("Preparing view snapshot")
// TODO: Apply namespace // TODO: Apply namespace
// TODO: Lookup snapshot id from metadata store // TODO: Lookup snapshot id from metadata store
@ -81,7 +82,9 @@ func (s *service) View(ctx context.Context, pr *snapshotapi.PrepareRequest) (*sn
if err != nil { if err != nil {
return nil, grpcError(err) return nil, grpcError(err)
} }
return fromMounts(mounts), nil return &snapshotapi.ViewSnapshotResponse{
Mounts: fromMounts(mounts),
}, nil
} }
func (s *service) Mounts(ctx context.Context, mr *snapshotapi.MountsRequest) (*snapshotapi.MountsResponse, error) { func (s *service) Mounts(ctx context.Context, mr *snapshotapi.MountsRequest) (*snapshotapi.MountsResponse, error) {
@ -92,10 +95,12 @@ func (s *service) Mounts(ctx context.Context, mr *snapshotapi.MountsRequest) (*s
if err != nil { if err != nil {
return nil, grpcError(err) return nil, grpcError(err)
} }
return fromMounts(mounts), nil return &snapshotapi.MountsResponse{
Mounts: fromMounts(mounts),
}, nil
} }
func (s *service) Commit(ctx context.Context, cr *snapshotapi.CommitRequest) (*protoempty.Empty, error) { func (s *service) Commit(ctx context.Context, cr *snapshotapi.CommitSnapshotRequest) (*protoempty.Empty, error) {
log.G(ctx).WithField("key", cr.Key).WithField("name", cr.Name).Debugf("Committing snapshot") log.G(ctx).WithField("key", cr.Key).WithField("name", cr.Name).Debugf("Committing snapshot")
// TODO: Apply namespace // TODO: Apply namespace
// TODO: Lookup snapshot id from metadata store // TODO: Lookup snapshot id from metadata store
@ -112,7 +117,7 @@ func (s *service) Commit(ctx context.Context, cr *snapshotapi.CommitRequest) (*p
return empty, nil return empty, nil
} }
func (s *service) Remove(ctx context.Context, rr *snapshotapi.RemoveRequest) (*protoempty.Empty, error) { func (s *service) Remove(ctx context.Context, rr *snapshotapi.RemoveSnapshotRequest) (*protoempty.Empty, error) {
log.G(ctx).WithField("key", rr.Key).Debugf("Removing snapshot") log.G(ctx).WithField("key", rr.Key).Debugf("Removing snapshot")
// TODO: Apply namespace // TODO: Apply namespace
// TODO: Lookup snapshot id from metadata store // TODO: Lookup snapshot id from metadata store
@ -128,7 +133,7 @@ func (s *service) Remove(ctx context.Context, rr *snapshotapi.RemoveRequest) (*p
return empty, nil return empty, nil
} }
func (s *service) Stat(ctx context.Context, sr *snapshotapi.StatRequest) (*snapshotapi.StatResponse, error) { func (s *service) Stat(ctx context.Context, sr *snapshotapi.StatSnapshotRequest) (*snapshotapi.StatSnapshotResponse, error) {
log.G(ctx).WithField("key", sr.Key).Debugf("Statting snapshot") log.G(ctx).WithField("key", sr.Key).Debugf("Statting snapshot")
// TODO: Apply namespace // TODO: Apply namespace
info, err := s.snapshotter.Stat(ctx, sr.Key) info, err := s.snapshotter.Stat(ctx, sr.Key)
@ -136,16 +141,15 @@ func (s *service) Stat(ctx context.Context, sr *snapshotapi.StatRequest) (*snaps
return nil, grpcError(err) return nil, grpcError(err)
} }
return &snapshotapi.StatResponse{Info: fromInfo(info)}, nil return &snapshotapi.StatSnapshotResponse{Info: fromInfo(info)}, nil
} }
func (s *service) List(sr *snapshotapi.ListRequest, ss snapshotapi.Snapshot_ListServer) error { func (s *service) List(sr *snapshotapi.ListSnapshotsRequest, ss snapshotapi.Snapshots_ListServer) error {
// TODO: Apply namespace // TODO: Apply namespace
var ( var (
buffer []snapshotapi.Info buffer []snapshotapi.Info
sendBlock = func(block []snapshotapi.Info) error { sendBlock = func(block []snapshotapi.Info) error {
return ss.Send(&snapshotapi.ListResponse{ return ss.Send(&snapshotapi.ListSnapshotsResponse{
Info: block, Info: block,
}) })
} }
@ -223,18 +227,16 @@ func fromUsage(usage snapshot.Usage) *snapshotapi.UsageResponse {
} }
} }
func fromMounts(mounts []mount.Mount) *snapshotapi.MountsResponse { func fromMounts(mounts []mount.Mount) []*mounttypes.Mount {
resp := &snapshotapi.MountsResponse{ out := make([]*mounttypes.Mount, len(mounts))
Mounts: make([]*mounttypes.Mount, len(mounts)),
}
for i, m := range mounts { for i, m := range mounts {
resp.Mounts[i] = &mounttypes.Mount{ out[i] = &mounttypes.Mount{
Type: m.Type, Type: m.Type,
Source: m.Source, Source: m.Source,
Options: m.Options, Options: m.Options,
} }
} }
return resp return out
} }
func (s *service) emit(ctx context.Context, topic string, evt interface{}) error { func (s *service) emit(ctx context.Context, topic string, evt interface{}) error {

77
task.go
View File

@ -12,7 +12,6 @@ import (
"github.com/containerd/containerd/api/services/containers" "github.com/containerd/containerd/api/services/containers"
"github.com/containerd/containerd/api/services/execution" "github.com/containerd/containerd/api/services/execution"
taskapi "github.com/containerd/containerd/api/types/task"
"github.com/containerd/containerd/content" "github.com/containerd/containerd/content"
"github.com/containerd/containerd/rootfs" "github.com/containerd/containerd/rootfs"
"github.com/opencontainers/image-spec/specs-go/v1" "github.com/opencontainers/image-spec/specs-go/v1"
@ -31,7 +30,13 @@ const (
Pausing TaskStatus = "pausing" Pausing TaskStatus = "pausing"
) )
type CheckpointOpts func(*execution.CheckpointRequest) error type IOCloserOpts func(*execution.CloseIORequest)
func WithStdinCloser(r *execution.CloseIORequest) {
r.Stdin = true
}
type CheckpointOpts func(*execution.CheckpointTaskRequest) error
type Task interface { type Task interface {
Pid() uint32 Pid() uint32
@ -44,7 +49,7 @@ type Task interface {
Wait(context.Context) (uint32, error) Wait(context.Context) (uint32, error)
Exec(context.Context, *specs.Process, IOCreation) (Process, error) Exec(context.Context, *specs.Process, IOCreation) (Process, error)
Processes(context.Context) ([]uint32, error) Processes(context.Context) ([]uint32, error)
CloseStdin(context.Context) error CloseIO(context.Context, ...IOCloserOpts) error
Resize(ctx context.Context, w, h uint32) error Resize(ctx context.Context, w, h uint32) error
IO() *IO IO() *IO
Checkpoint(context.Context, ...CheckpointOpts) (v1.Descriptor, error) Checkpoint(context.Context, ...CheckpointOpts) (v1.Descriptor, error)
@ -56,7 +61,7 @@ type Process interface {
Delete(context.Context) (uint32, error) Delete(context.Context) (uint32, error)
Kill(context.Context, syscall.Signal) error Kill(context.Context, syscall.Signal) error
Wait(context.Context) (uint32, error) Wait(context.Context) (uint32, error)
CloseStdin(context.Context) error CloseIO(context.Context, ...IOCloserOpts) error
Resize(ctx context.Context, w, h uint32) error Resize(ctx context.Context, w, h uint32) error
IO() *IO IO() *IO
} }
@ -70,7 +75,7 @@ type task struct {
containerID string containerID string
pid uint32 pid uint32
deferred *execution.CreateRequest deferred *execution.CreateTaskRequest
pidSync chan struct{} pidSync chan struct{}
} }
@ -90,7 +95,7 @@ func (t *task) Start(ctx context.Context) error {
close(t.pidSync) close(t.pidSync)
return nil return nil
} }
_, err := t.client.TaskService().Start(ctx, &execution.StartRequest{ _, err := t.client.TaskService().Start(ctx, &execution.StartTaskRequest{
ContainerID: t.containerID, ContainerID: t.containerID,
}) })
return err return err
@ -108,21 +113,21 @@ func (t *task) Kill(ctx context.Context, s syscall.Signal) error {
} }
func (t *task) Pause(ctx context.Context) error { func (t *task) Pause(ctx context.Context) error {
_, err := t.client.TaskService().Pause(ctx, &execution.PauseRequest{ _, err := t.client.TaskService().Pause(ctx, &execution.PauseTaskRequest{
ContainerID: t.containerID, ContainerID: t.containerID,
}) })
return err return err
} }
func (t *task) Resume(ctx context.Context) error { func (t *task) Resume(ctx context.Context) error {
_, err := t.client.TaskService().Resume(ctx, &execution.ResumeRequest{ _, err := t.client.TaskService().Resume(ctx, &execution.ResumeTaskRequest{
ContainerID: t.containerID, ContainerID: t.containerID,
}) })
return err return err
} }
func (t *task) Status(ctx context.Context) (TaskStatus, error) { func (t *task) Status(ctx context.Context) (TaskStatus, error) {
r, err := t.client.TaskService().Info(ctx, &execution.InfoRequest{ r, err := t.client.TaskService().Get(ctx, &execution.GetTaskRequest{
ContainerID: t.containerID, ContainerID: t.containerID,
}) })
if err != nil { if err != nil {
@ -133,23 +138,7 @@ func (t *task) Status(ctx context.Context) (TaskStatus, error) {
// Wait is a blocking call that will wait for the task to exit and return the exit status // Wait is a blocking call that will wait for the task to exit and return the exit status
func (t *task) Wait(ctx context.Context) (uint32, error) { func (t *task) Wait(ctx context.Context) (uint32, error) {
events, err := t.client.TaskService().Events(ctx, &execution.EventsRequest{}) return 255, fmt.Errorf("not implemented")
if err != nil {
return UnknownExitStatus, err
}
<-t.pidSync
for {
e, err := events.Recv()
if err != nil {
return UnknownExitStatus, err
}
if e.Type != taskapi.Event_EXIT {
continue
}
if e.ID == t.containerID && e.Pid == t.pid {
return e.ExitStatus, nil
}
}
} }
// Delete deletes the task and its runtime state // Delete deletes the task and its runtime state
@ -160,7 +149,7 @@ func (t *task) Delete(ctx context.Context) (uint32, error) {
if t.io != nil { if t.io != nil {
cerr = t.io.Close() cerr = t.io.Close()
} }
r, err := t.client.TaskService().Delete(ctx, &execution.DeleteRequest{ r, err := t.client.TaskService().Delete(ctx, &execution.DeleteTaskRequest{
ContainerID: t.containerID, ContainerID: t.containerID,
}) })
if err != nil { if err != nil {
@ -183,7 +172,7 @@ func (t *task) Exec(ctx context.Context, spec *specs.Process, ioCreate IOCreatio
} }
func (t *task) Processes(ctx context.Context) ([]uint32, error) { func (t *task) Processes(ctx context.Context) ([]uint32, error) {
response, err := t.client.TaskService().Processes(ctx, &execution.ProcessesRequest{ response, err := t.client.TaskService().ListProcesses(ctx, &execution.ListProcessesRequest{
ContainerID: t.containerID, ContainerID: t.containerID,
}) })
if err != nil { if err != nil {
@ -196,11 +185,15 @@ func (t *task) Processes(ctx context.Context) ([]uint32, error) {
return out, nil return out, nil
} }
func (t *task) CloseStdin(ctx context.Context) error { func (t *task) CloseIO(ctx context.Context, opts ...IOCloserOpts) error {
_, err := t.client.TaskService().CloseStdin(ctx, &execution.CloseStdinRequest{ r := &execution.CloseIORequest{
ContainerID: t.containerID, ContainerID: t.containerID,
Pid: t.pid, Pid: t.pid,
}) }
for _, o := range opts {
o(r)
}
_, err := t.client.TaskService().CloseIO(ctx, r)
return err return err
} }
@ -209,7 +202,7 @@ func (t *task) IO() *IO {
} }
func (t *task) Resize(ctx context.Context, w, h uint32) error { func (t *task) Resize(ctx context.Context, w, h uint32) error {
_, err := t.client.TaskService().Pty(ctx, &execution.PtyRequest{ _, err := t.client.TaskService().ResizePty(ctx, &execution.ResizePtyRequest{
ContainerID: t.containerID, ContainerID: t.containerID,
Width: w, Width: w,
Height: h, Height: h,
@ -218,28 +211,26 @@ func (t *task) Resize(ctx context.Context, w, h uint32) error {
return err return err
} }
func WithExit(r *execution.CheckpointRequest) error { func WithExit(r *execution.CheckpointTaskRequest) error {
r.Exit = true r.Options["exit"] = "true"
return nil return nil
} }
func (t *task) Checkpoint(ctx context.Context, opts ...CheckpointOpts) (d v1.Descriptor, err error) { func (t *task) Checkpoint(ctx context.Context, opts ...CheckpointOpts) (d v1.Descriptor, err error) {
request := &execution.CheckpointRequest{ request := &execution.CheckpointTaskRequest{
ContainerID: t.containerID, ContainerID: t.containerID,
Options: make(map[string]string),
} }
for _, o := range opts { for _, o := range opts {
if err := o(request); err != nil { if err := o(request); err != nil {
return d, err return d, err
} }
} }
// if we are not exiting the container after the checkpoint, make sure we pause it and resume after // make sure we pause it and resume after all other filesystem operations are completed
// all other filesystem operations are completed if err := t.Pause(ctx); err != nil {
if !request.Exit { return d, err
if err := t.Pause(ctx); err != nil {
return d, err
}
defer t.Resume(ctx)
} }
defer t.Resume(ctx)
cr, err := t.client.ContainerService().Get(ctx, &containers.GetContainerRequest{ cr, err := t.client.ContainerService().Get(ctx, &containers.GetContainerRequest{
ID: t.containerID, ID: t.containerID,
}) })
@ -261,7 +252,7 @@ func (t *task) Checkpoint(ctx context.Context, opts ...CheckpointOpts) (d v1.Des
return t.writeIndex(ctx, &index) return t.writeIndex(ctx, &index)
} }
func (t *task) checkpointTask(ctx context.Context, index *v1.Index, request *execution.CheckpointRequest) error { func (t *task) checkpointTask(ctx context.Context, index *v1.Index, request *execution.CheckpointTaskRequest) error {
response, err := t.client.TaskService().Checkpoint(ctx, request) response, err := t.client.TaskService().Checkpoint(ctx, request)
if err != nil { if err != nil {
return err return err