Update GRPC for consistency

Signed-off-by: Michael Crosby <crosbymichael@gmail.com>

api/services/containers/containers.pb.go

@@ -75,9 +75,9 @@ type Container struct {
 	// 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"`
 	// 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 *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
 	// filesystem. When starting a task from this container, a caller should
 	// 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.
 	//
 	// 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 (*Container) ProtoMessage()               {}
 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 {
 	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 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.
@@ -223,7 +237,7 @@ func NewContainersClient(cc *grpc.ClientConn) ContainersClient {
 
 func (c *containersClient) Get(ctx context.Context, in *GetContainerRequest, opts ...grpc.CallOption) (*GetContainerResponse, error) {
 	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 {
 		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) {
 	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 {
 		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) {
 	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 {
 		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) {
 	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 {
 		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) {
 	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 {
 		return nil, err
 	}
@@ -290,7 +304,7 @@ func _Containers_Get_Handler(srv interface{}, ctx context.Context, dec func(inte
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/containerd.v1.Containers/Get",
+		FullMethod: "/containerd.services.containers.v1.Containers/Get",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		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{
 		Server:     srv,
-		FullMethod: "/containerd.v1.Containers/List",
+		FullMethod: "/containerd.services.containers.v1.Containers/List",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		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{
 		Server:     srv,
-		FullMethod: "/containerd.v1.Containers/Create",
+		FullMethod: "/containerd.services.containers.v1.Containers/Create",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		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{
 		Server:     srv,
-		FullMethod: "/containerd.v1.Containers/Update",
+		FullMethod: "/containerd.services.containers.v1.Containers/Update",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		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{
 		Server:     srv,
-		FullMethod: "/containerd.v1.Containers/Delete",
+		FullMethod: "/containerd.services.containers.v1.Containers/Delete",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		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{
-	ServiceName: "containerd.v1.Containers",
+	ServiceName: "containerd.services.containers.v1.Containers",
 	HandlerType: (*ContainersServer)(nil),
 	Methods: []grpc.MethodDesc{
 		{
@@ -443,44 +457,89 @@ func (m *Container) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintContainers(dAtA, i, uint64(len(m.Image)))
 		i += copy(dAtA[i:], m.Image)
 	}
-	if len(m.Runtime) > 0 {
+	if m.Runtime != nil {
 		dAtA[i] = 0x22
 		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 {
 			return 0, err
 		}
 		i += n1
 	}
-	if len(m.RootFS) > 0 {
+	if m.Spec != nil {
-		dAtA[i] = 0x3a
+		dAtA[i] = 0x2a
 		i++
-		i = encodeVarintContainers(dAtA, i, uint64(len(m.RootFS)))
+		i = encodeVarintContainers(dAtA, i, uint64(m.Spec.Size()))
-		i += copy(dAtA[i:], m.RootFS)
+		n2, err := m.Spec.MarshalTo(dAtA[i:])
-	}
-	dAtA[i] = 0x42
-	i++
-	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:])
 		if err != nil {
 			return 0, err
 		}
 		i += n2
-	dAtA[i] = 0x4a
+	}
+	if len(m.RootFS) > 0 {
+		dAtA[i] = 0x32
 		i++
-	i = encodeVarintContainers(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt)))
+		i = encodeVarintContainers(dAtA, i, uint64(len(m.RootFS)))
-	n3, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UpdatedAt, dAtA[i:])
+		i += copy(dAtA[i:], m.RootFS)
+	}
+	dAtA[i] = 0x3a
+	i++
+	i = encodeVarintContainers(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt)))
+	n3, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CreatedAt, dAtA[i:])
 	if err != nil {
 		return 0, err
 	}
 	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
 }
 
@@ -526,11 +585,11 @@ func (m *GetContainerResponse) MarshalTo(dAtA []byte) (int, error) {
 	dAtA[i] = 0xa
 	i++
 	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 {
 		return 0, err
 	}
-	i += n4
+	i += n5
 	return i, nil
 }
 
@@ -606,11 +665,11 @@ func (m *CreateContainerRequest) MarshalTo(dAtA []byte) (int, error) {
 	dAtA[i] = 0xa
 	i++
 	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 {
 		return 0, err
 	}
-	i += n5
+	i += n6
 	return i, nil
 }
 
@@ -632,11 +691,11 @@ func (m *CreateContainerResponse) MarshalTo(dAtA []byte) (int, error) {
 	dAtA[i] = 0xa
 	i++
 	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 {
 		return 0, err
 	}
-	i += n6
+	i += n7
 	return i, nil
 }
 
@@ -658,20 +717,20 @@ func (m *UpdateContainerRequest) MarshalTo(dAtA []byte) (int, error) {
 	dAtA[i] = 0xa
 	i++
 	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 {
-		return 0, err
-	}
-	i += n7
-	if m.UpdateMask != nil {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintContainers(dAtA, i, uint64(m.UpdateMask.Size()))
-		n8, err := m.UpdateMask.MarshalTo(dAtA[i:])
 	if err != nil {
 		return 0, err
 	}
 	i += n8
+	if m.UpdateMask != nil {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintContainers(dAtA, i, uint64(m.UpdateMask.Size()))
+		n9, err := m.UpdateMask.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n9
 	}
 	return i, nil
 }
@@ -694,11 +753,11 @@ func (m *UpdateContainerResponse) MarshalTo(dAtA []byte) (int, error) {
 	dAtA[i] = 0xa
 	i++
 	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 {
 		return 0, err
 	}
-	i += n9
+	i += n10
 	return i, nil
 }
 
@@ -772,8 +831,8 @@ func (m *Container) Size() (n int) {
 	if l > 0 {
 		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))
 	}
 	if m.Spec != nil {
@@ -791,6 +850,24 @@ func (m *Container) Size() (n int) {
 	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) {
 	var l int
 	_ = l
@@ -908,7 +985,7 @@ func (this *Container) String() string {
 		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
 		`Labels:` + mapStringForLabels + `,`,
 		`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) + `,`,
 		`RootFS:` + fmt.Sprintf("%v", this.RootFS) + `,`,
 		`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
 }
+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 {
 	if this == nil {
 		return "nil"
@@ -1223,7 +1321,7 @@ func (m *Container) Unmarshal(dAtA []byte) error {
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Runtime", wireType)
 			}
-			var stringLen uint64
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowContainers
@@ -1233,22 +1331,26 @@ func (m *Container) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
+			if msglen < 0 {
-			if intStringLen < 0 {
 				return ErrInvalidLengthContainers
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + msglen
 			if postIndex > l {
 				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
-		case 6:
+		case 5:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
 			}
@@ -1281,7 +1383,7 @@ func (m *Container) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
-		case 7:
+		case 6:
 			if wireType != 2 {
 				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])
 			iNdEx = postIndex
-		case 8:
+		case 7:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
 			}
@@ -1340,7 +1442,7 @@ func (m *Container) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
-		case 9:
+		case 8:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAt", wireType)
 			}
@@ -1391,6 +1493,201 @@ func (m *Container) Unmarshal(dAtA []byte) error {
 	}
 	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 {
 	l := len(dAtA)
 	iNdEx := 0
@@ -2252,48 +2549,52 @@ func init() {
 }
 
 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,
 }

api/services/containers/containers.proto

@@ -1,6 +1,6 @@
 syntax = "proto3";
 
-package containerd.v1;
+package containerd.services.containers.v1;
 
 import "gogoproto/gogo.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.
 	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.
-	string runtime = 4;
+	Runtime runtime = 4;
 
 	// 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
 	// 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.
 	//
 	// 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 {

api/services/content/content.proto

@@ -1,6 +1,6 @@
 syntax = "proto3";
 
-package containerd.v1;
+package containerd.services.content.v1;
 
 import "gogoproto/gogo.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.
 	//
 	// 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
 	// Write.
@@ -54,7 +54,7 @@ service Content {
 	//
 	// 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.
-	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
 	// 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];
 }
 
-// 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.
-message ReadRequest {
+message ReadContentRequest {
 	// Digest is the hash identity to read.
 	string digest = 1 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false];
 
@@ -107,16 +107,12 @@ message ReadRequest {
 	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
 	bytes data = 2; // actual data
 }
 
-message StatusRequest {
-	string regexp = 1;
-}
-
 message Status {
 	google.protobuf.Timestamp started_at = 1 [(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];
 }
 
+message StatusRequest {
+	string filter = 1;
+}
+
 message StatusResponse {
 	repeated Status statuses = 1 [(gogoproto.nullable) = false];
 }
@@ -157,8 +157,8 @@ enum WriteAction {
 	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.
 	//
 	// 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;
 }
 
-// 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
 	// should confirm that they match the intended result.
 	WriteAction action = 1;

api/services/diff/diff.pb.go

@@ -96,10 +96,10 @@ func (*DiffResponse) ProtoMessage()               {}
 func (*DiffResponse) Descriptor() ([]byte, []int) { return fileDescriptorDiff, []int{3} }
 
 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.
@@ -132,7 +132,7 @@ func NewDiffClient(cc *grpc.ClientConn) DiffClient {
 
 func (c *diffClient) Apply(ctx context.Context, in *ApplyRequest, opts ...grpc.CallOption) (*ApplyResponse, error) {
 	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 {
 		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) {
 	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 {
 		return nil, err
 	}
@@ -174,7 +174,7 @@ func _Diff_Apply_Handler(srv interface{}, ctx context.Context, dec func(interfac
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/containerd.v1.Diff/Apply",
+		FullMethod: "/containerd.services.diff.v1.Diff/Apply",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		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{
 		Server:     srv,
-		FullMethod: "/containerd.v1.Diff/Diff",
+		FullMethod: "/containerd.services.diff.v1.Diff/Diff",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		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{
-	ServiceName: "containerd.v1.Diff",
+	ServiceName: "containerd.services.diff.v1.Diff",
 	HandlerType: (*DiffServer)(nil),
 	Methods: []grpc.MethodDesc{
 		{
@@ -1081,31 +1081,32 @@ func init() {
 }
 
 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,
 }

api/services/diff/diff.proto

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

api/services/events/events.pb.go

@@ -9,7 +9,7 @@
 		github.com/containerd/containerd/api/services/events/events.proto
 
 	It has these top-level messages:
-		EventStreamRequest
+		StreamEventsRequest
 */
 package events
 
@@ -39,15 +39,15 @@ var _ = math.Inf
 // proto package needs to be updated.
 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() {
-	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.
@@ -61,7 +61,7 @@ const _ = grpc.SupportPackageIsVersion4
 // Client API for Events service
 
 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 {
@@ -72,12 +72,12 @@ func NewEventsClient(cc *grpc.ClientConn) EventsClient {
 	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 {
 		return nil, err
 	}
-	x := &eventsEventStreamClient{stream}
+	x := &eventsStreamClient{stream}
 	if err := x.ClientStream.SendMsg(in); err != nil {
 		return nil, err
 	}
@@ -87,16 +87,16 @@ func (c *eventsClient) EventStream(ctx context.Context, in *EventStreamRequest,
 	return x, nil
 }
 
-type Events_EventStreamClient interface {
+type Events_StreamClient interface {
 	Recv() (*containerd_v1_types.Envelope, error)
 	grpc.ClientStream
 }
 
-type eventsEventStreamClient struct {
+type eventsStreamClient struct {
 	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)
 	if err := x.ClientStream.RecvMsg(m); err != nil {
 		return nil, err
@@ -107,49 +107,49 @@ func (x *eventsEventStreamClient) Recv() (*containerd_v1_types.Envelope, error)
 // Server API for Events service
 
 type EventsServer interface {
-	EventStream(*EventStreamRequest, Events_EventStreamServer) error
+	Stream(*StreamEventsRequest, Events_StreamServer) error
 }
 
 func RegisterEventsServer(s *grpc.Server, srv EventsServer) {
 	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 {
 		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
 	grpc.ServerStream
 }
 
-type eventsEventStreamServer struct {
+type eventsStreamServer struct {
 	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)
 }
 
 var _Events_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "containerd.v1.services.events.Events",
+	ServiceName: "containerd.services.events.v1.Events",
 	HandlerType: (*EventsServer)(nil),
 	Methods:     []grpc.MethodDesc{},
 	Streams: []grpc.StreamDesc{
 		{
-			StreamName:    "EventStream",
+			StreamName:    "Stream",
-			Handler:       _Events_EventStream_Handler,
+			Handler:       _Events_Stream_Handler,
 			ServerStreams: true,
 		},
 	},
 	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()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalTo(dAtA)
@@ -159,7 +159,7 @@ func (m *EventStreamRequest) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *EventStreamRequest) MarshalTo(dAtA []byte) (int, error) {
+func (m *StreamEventsRequest) MarshalTo(dAtA []byte) (int, error) {
 	var i int
 	_ = i
 	var l int
@@ -194,7 +194,7 @@ func encodeVarintEvents(dAtA []byte, offset int, v uint64) int {
 	dAtA[offset] = uint8(v)
 	return offset + 1
 }
-func (m *EventStreamRequest) Size() (n int) {
+func (m *StreamEventsRequest) Size() (n int) {
 	var l int
 	_ = l
 	return n
@@ -213,11 +213,11 @@ func sovEvents(x uint64) (n int) {
 func sozEvents(x uint64) (n int) {
 	return sovEvents(uint64((x << 1) ^ uint64((int64(x) >> 63))))
 }
-func (this *EventStreamRequest) String() string {
+func (this *StreamEventsRequest) String() string {
 	if this == nil {
 		return "nil"
 	}
-	s := strings.Join([]string{`&EventStreamRequest{`,
+	s := strings.Join([]string{`&StreamEventsRequest{`,
 		`}`,
 	}, "")
 	return s
@@ -230,7 +230,7 @@ func valueToStringEvents(v interface{}) string {
 	pv := reflect.Indirect(rv).Interface()
 	return fmt.Sprintf("*%v", pv)
 }
-func (m *EventStreamRequest) Unmarshal(dAtA []byte) error {
+func (m *StreamEventsRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -253,10 +253,10 @@ func (m *EventStreamRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		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 {
-			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 {
 		default:
@@ -390,17 +390,18 @@ func init() {
 }
 
 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,
 	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,
 	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,
 }

api/services/events/events.proto

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

api/services/execution/execution.proto

@@ -1,6 +1,6 @@
 syntax = "proto3";
 
-package containerd.v1.services.execution;
+package containerd.services.tasks.v1;
 
 import "google/protobuf/empty.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";
 
 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 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 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.
 	//
 	// 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
 	// per container.
-	//
-	// This should be created using the Containers service.
 	string container_id = 2;
 
 	// RootFS provides the pre-chroot mounts to perform in the shim before
@@ -46,15 +62,15 @@ message CreateRequest {
 	// the container object.
 	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
 	// to a single container. Although, we should represent each new task with
 	// an ID so one can differentiate between each instance of a container
@@ -68,11 +84,11 @@ message CreateResponse {
 	uint32 pid = 3;
 }
 
-message StartRequest {
+message StartTaskRequest {
 	string container_id = 1;
 }
 
-message DeleteRequest {
+message DeleteTaskRequest {
 	string container_id = 1;
 }
 
@@ -87,18 +103,19 @@ message DeleteProcessRequest {
 	uint32 pid = 2;
 }
 
-message InfoRequest {
+message GetTaskRequest {
 	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;
 }
 
@@ -111,16 +128,14 @@ message KillRequest {
 	}
 }
 
-message EventsRequest {
+message ExecProcessRequest {
-}
-
-message ExecRequest {
 	// ContainerID specifies the container in which to exec the process.
 	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.
 	//
@@ -128,49 +143,45 @@ message ExecRequest {
 	google.protobuf.Any spec = 6;
 }
 
-message ExecResponse {
+message ExecProcessResponse {
 	uint32 pid = 1;
 }
 
-message PtyRequest {
+message ResizePtyRequest {
 	string container_id = 1;
 	uint32 pid = 2;
 	uint32 width = 3;
 	uint32 height = 4;
 }
 
-message CloseStdinRequest {
+message CloseIORequest {
 	string container_id = 1;
 	uint32 pid = 2;
+	bool stdin = 3;
 }
 
-message PauseRequest {
+message PauseTaskRequest {
 	string container_id = 1;
 }
 
-message ResumeRequest {
+message ResumeTaskRequest {
 	string container_id = 1;
 }
 
-message ProcessesRequest {
+message ListProcessesRequest {
 	string container_id = 1;
 }
 
-message ProcessesResponse{
+message ListProcessesResponse{
 	repeated containerd.v1.types.Process processes = 1;
 }
 
-message CheckpointRequest {
+message CheckpointTaskRequest {
 	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;
 }

api/services/images/images.proto

@@ -1,10 +1,9 @@
 syntax = "proto3";
 
-package containerd.v1;
+package containerd.services.images.v1;
 
 import "gogoproto/gogo.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";
 
 // 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".
 service Images {
 	// 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.
-	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.
-	rpc Put(PutRequest) returns (google.protobuf.Empty);
+	rpc Update(UpdateImageRequest) returns (UpdateImageResponse);
 
 	// Delete deletes the image by name.
-	rpc Delete(DeleteRequest) returns (google.protobuf.Empty);
+	rpc Delete(DeleteImageRequest) returns (google.protobuf.Empty);
 }
 
 message Image {
 	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;
-
-	// 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;
 }
 
-message PutRequest {
+message UpdateImageRequest {
 	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];
-
-	// TODO(stevvooe): Add pagination.
 }
 
-message DeleteRequest {
+message DeleteImageRequest {
 	string name = 1;
 }

api/services/namespaces/namespace.pb.go

@@ -152,16 +152,16 @@ func (*DeleteNamespaceRequest) ProtoMessage()               {}
 func (*DeleteNamespaceRequest) Descriptor() ([]byte, []int) { return fileDescriptorNamespace, []int{9} }
 
 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.
@@ -192,7 +192,7 @@ func NewNamespacesClient(cc *grpc.ClientConn) NamespacesClient {
 
 func (c *namespacesClient) Get(ctx context.Context, in *GetNamespaceRequest, opts ...grpc.CallOption) (*GetNamespaceResponse, error) {
 	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 {
 		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) {
 	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 {
 		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) {
 	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 {
 		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) {
 	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 {
 		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) {
 	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 {
 		return nil, err
 	}
@@ -259,7 +259,7 @@ func _Namespaces_Get_Handler(srv interface{}, ctx context.Context, dec func(inte
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/containerd.v1.namespaces.Namespaces/Get",
+		FullMethod: "/containerd.services.namespaces.v1.Namespaces/Get",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		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{
 		Server:     srv,
-		FullMethod: "/containerd.v1.namespaces.Namespaces/List",
+		FullMethod: "/containerd.services.namespaces.v1.Namespaces/List",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		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{
 		Server:     srv,
-		FullMethod: "/containerd.v1.namespaces.Namespaces/Create",
+		FullMethod: "/containerd.services.namespaces.v1.Namespaces/Create",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		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{
 		Server:     srv,
-		FullMethod: "/containerd.v1.namespaces.Namespaces/Update",
+		FullMethod: "/containerd.services.namespaces.v1.Namespaces/Update",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		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{
 		Server:     srv,
-		FullMethod: "/containerd.v1.namespaces.Namespaces/Delete",
+		FullMethod: "/containerd.services.namespaces.v1.Namespaces/Delete",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		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{
-	ServiceName: "containerd.v1.namespaces.Namespaces",
+	ServiceName: "containerd.services.namespaces.v1.Namespaces",
 	HandlerType: (*NamespacesServer)(nil),
 	Methods: []grpc.MethodDesc{
 		{
@@ -1971,38 +1971,39 @@ func init() {
 }
 
 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,
 }

api/services/namespaces/namespace.proto

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

api/services/shim/shim.pb.go

@@ -54,6 +54,7 @@ import github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
 
 import strings "strings"
 import reflect "reflect"
+import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
 
 import io "io"
 
@@ -252,13 +253,8 @@ func (*ProcessesResponse) ProtoMessage()               {}
 func (*ProcessesResponse) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{19} }
 
 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{} }
@@ -266,27 +262,27 @@ func (*CheckpointRequest) ProtoMessage()               {}
 func (*CheckpointRequest) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{20} }
 
 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.
@@ -327,7 +323,7 @@ func NewShimClient(cc *grpc.ClientConn) ShimClient {
 
 func (c *shimClient) Create(ctx context.Context, in *CreateRequest, opts ...grpc.CallOption) (*CreateResponse, error) {
 	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 {
 		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) {
 	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 {
 		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) {
 	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 {
 		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) {
 	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 {
 		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) {
 	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 {
 		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) {
 	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 {
 		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) {
 	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 {
 		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) {
 	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 {
 		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) {
 	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 {
 		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) {
 	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 {
 		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) {
-	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 {
 		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) {
 	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 {
 		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) {
 	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 {
 		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) {
 	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 {
 		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) {
 	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 {
 		return nil, err
 	}
@@ -517,7 +513,7 @@ func _Shim_Create_Handler(srv interface{}, ctx context.Context, dec func(interfa
 	}
 	info := &grpc.UnaryServerInfo{
 		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) {
 		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{
 		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) {
 		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{
 		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) {
 		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{
 		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) {
 		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{
 		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) {
 		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{
 		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) {
 		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{
 		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) {
 		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{
 		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) {
 		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{
 		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) {
 		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{
 		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) {
 		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{
 		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) {
 		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{
 		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) {
 		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{
 		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) {
 		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{
 		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) {
 		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{
-	ServiceName: "containerd.v1.services.shim.Shim",
+	ServiceName: "containerd.runtime.linux.shim.v1.Shim",
 	HandlerType: (*ShimServer)(nil),
 	Methods: []grpc.MethodDesc{
 		{
@@ -1508,76 +1504,28 @@ func (m *CheckpointRequest) MarshalTo(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.Exit {
+	if len(m.Path) > 0 {
-		dAtA[i] = 0x8
+		dAtA[i] = 0xa
 		i++
-		if m.Exit {
+		i = encodeVarintShim(dAtA, i, uint64(len(m.Path)))
-			dAtA[i] = 1
+		i += copy(dAtA[i:], m.Path)
-		} else {
-			dAtA[i] = 0
 	}
+	if len(m.Options) > 0 {
+		for k, _ := range m.Options {
+			dAtA[i] = 0x12
 			i++
+			v := m.Options[k]
+			mapSize := 1 + len(k) + sovShim(uint64(len(k))) + 1 + len(v) + sovShim(uint64(len(v)))
+			i = encodeVarintShim(dAtA, i, uint64(mapSize))
+			dAtA[i] = 0xa
+			i++
+			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 m.AllowTcp {
-		dAtA[i] = 0x10
-		i++
-		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++
-			l = len(s)
-			for l >= 1<<7 {
-				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
-				l >>= 7
-				i++
-			}
-			dAtA[i] = uint8(l)
-			i++
-			i += copy(dAtA[i:], s)
-		}
-	}
-	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
 }
@@ -1885,31 +1833,18 @@ func (m *ProcessesResponse) Size() (n int) {
 func (m *CheckpointRequest) Size() (n int) {
 	var l int
 	_ = 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 {
 		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
 }
 
@@ -2152,14 +2087,19 @@ func (this *CheckpointRequest) 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{`&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
@@ -4246,108 +4186,8 @@ func (m *CheckpointRequest) Unmarshal(dAtA []byte) error {
 		}
 		switch fieldNum {
 		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 {
-				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
 			for shift := uint(0); ; shift += 7 {
@@ -4372,13 +4212,13 @@ func (m *CheckpointRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.EmptyNamespaces = append(m.EmptyNamespaces, string(dAtA[iNdEx:postIndex]))
+			m.Path = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
-		case 7:
+		case 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 {
 				if shift >= 64 {
 					return ErrIntOverflowShim
@@ -4388,20 +4228,107 @@ func (m *CheckpointRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
+			if msglen < 0 {
-			if intStringLen < 0 {
 				return ErrInvalidLengthShim
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + msglen
 			if postIndex > l {
 				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
 		default:
 			iNdEx = preIndex
@@ -4534,78 +4461,75 @@ func init() {
 }
 
 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,
 }

api/services/shim/shim.proto

@@ -1,6 +1,6 @@
 syntax = "proto3";
 
-package containerd.v1.services.shim;
+package containerd.runtime.linux.shim.v1;
 
 import "google/protobuf/any.proto";
 import "google/protobuf/empty.proto";
@@ -135,11 +135,6 @@ message ProcessesResponse{
 }
 
 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;
 }

api/services/snapshot/snapshots.proto

@@ -1,29 +1,41 @@
 syntax = "proto3";
 
-package containerd.v1.snapshot;
+package containerd.services.snapshots.v1;
 
 import "gogoproto/gogo.proto";
 import "google/protobuf/empty.proto";
 import "github.com/containerd/containerd/api/types/mount/mount.proto";
 
 // 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 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);
-	// "Snapshot" prepares a new set of mounts from existing name
 }
 
-message PrepareRequest {
+message PrepareSnapshotRequest {
 	string key = 1;
 	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 {
 	string key = 1;
 }
@@ -32,16 +44,16 @@ message MountsResponse {
 	repeated containerd.v1.types.Mount mounts = 1;
 }
 
-message RemoveRequest {
+message RemoveSnapshotRequest {
 	string key = 1;
 }
 
-message CommitRequest {
+message CommitSnapshotRequest {
 	string name = 1;
 	string key = 2;
 }
 
-message StatRequest {
+message StatSnapshotRequest {
 	string key = 1;
 }
 
@@ -61,13 +73,14 @@ message Info {
 	bool readonly = 4;
 }
 
-message StatResponse {
+message StatSnapshotResponse {
 	Info info = 1 [(gogoproto.nullable) = false];
 }
 
-message ListRequest{}
+message ListSnapshotsRequest{
+}
 
-message ListResponse {
+message ListSnapshotsResponse {
 	repeated Info info = 1 [(gogoproto.nullable) = false];
 }
 
@@ -76,6 +89,6 @@ message UsageRequest {
 }
 
 message UsageResponse {
-	int64 inodes = 2;
 	int64 size = 1;
+	int64 inodes = 2;
 }

api/services/version/version.pb.go

@@ -50,7 +50,7 @@ func (*VersionResponse) ProtoMessage()               {}
 func (*VersionResponse) Descriptor() ([]byte, []int) { return fileDescriptorVersion, []int{0} }
 
 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.
@@ -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) {
 	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 {
 		return nil, err
 	}
@@ -104,7 +104,7 @@ func _Version_Version_Handler(srv interface{}, ctx context.Context, dec func(int
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/containerd.v1.Version/Version",
+		FullMethod: "/containerd.services.version.v1.Version/Version",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		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{
-	ServiceName: "containerd.v1.Version",
+	ServiceName: "containerd.services.version.v1.Version",
 	HandlerType: (*VersionServer)(nil),
 	Methods: []grpc.MethodDesc{
 		{
@@ -446,20 +446,20 @@ func init() {
 }
 
 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,
 	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,
 	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,
 }

api/services/version/version.proto

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

api/types/event/container.pb.go

@@ -21,7 +21,7 @@
 		ContainerDelete
 		ContentDelete
 		Envelope
-		ImagePut
+		ImageUpdate
 		ImageDelete
 		NamespaceCreate
 		NamespaceUpdate
@@ -65,13 +65,24 @@ const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
 type ContainerCreate struct {
 	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"`
-	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 (*ContainerCreate) ProtoMessage()               {}
 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 {
 	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"`
@@ -93,6 +104,7 @@ func (*ContainerDelete) Descriptor() ([]byte, []int) { return fileDescriptorCont
 
 func init() {
 	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((*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 += copy(dAtA[i:], m.Image)
 	}
-	if len(m.Runtime) > 0 {
+	if m.Runtime != nil {
 		dAtA[i] = 0x1a
 		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
 }
@@ -247,10 +304,28 @@ func (m *ContainerCreate) Size() (n int) {
 	if l > 0 {
 		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 {
 		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
 }
 
@@ -310,7 +385,28 @@ func (this *ContainerCreate) String() string {
 	s := strings.Join([]string{`&ContainerCreate{`,
 		`ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`,
 		`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
@@ -447,6 +543,89 @@ func (m *ContainerCreate) Unmarshal(dAtA []byte) error {
 			if wireType != 2 {
 				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
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
@@ -470,7 +649,123 @@ func (m *ContainerCreate) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				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
 		default:
 			iNdEx = preIndex
@@ -935,26 +1230,30 @@ func init() {
 }
 
 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,
 }

api/types/event/container.proto

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

api/types/event/image.pb.go

@@ -10,6 +10,7 @@ import math "math"
 
 import strings "strings"
 import reflect "reflect"
+import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
 
 import io "io"
 
@@ -18,14 +19,14 @@ var _ = proto.Marshal
 var _ = fmt.Errorf
 var _ = math.Inf
 
-type ImagePut struct {
+type ImageUpdate struct {
 	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 {
 	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 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")
 }
-func (m *ImagePut) Marshal() (dAtA []byte, err error) {
+func (m *ImageUpdate) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalTo(dAtA)
@@ -49,7 +50,7 @@ func (m *ImagePut) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *ImagePut) MarshalTo(dAtA []byte) (int, error) {
+func (m *ImageUpdate) MarshalTo(dAtA []byte) (int, error) {
 	var i int
 	_ = i
 	var l int
@@ -61,10 +62,21 @@ func (m *ImagePut) MarshalTo(dAtA []byte) (int, error) {
 		i += copy(dAtA[i:], m.Name)
 	}
 	if len(m.Labels) > 0 {
+		for k, _ := range m.Labels {
 			dAtA[i] = 0x12
 			i++
-		i = encodeVarintImage(dAtA, i, uint64(len(m.Labels)))
+			v := m.Labels[k]
-		i += copy(dAtA[i:], m.Labels)
+			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
 }
@@ -120,16 +132,20 @@ func encodeVarintImage(dAtA []byte, offset int, v uint64) int {
 	dAtA[offset] = uint8(v)
 	return offset + 1
 }
-func (m *ImagePut) Size() (n int) {
+func (m *ImageUpdate) Size() (n int) {
 	var l int
 	_ = l
 	l = len(m.Name)
 	if l > 0 {
 		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
 }
@@ -157,13 +173,23 @@ func sovImage(x uint64) (n int) {
 func sozImage(x uint64) (n int) {
 	return sovImage(uint64((x << 1) ^ uint64((int64(x) >> 63))))
 }
-func (this *ImagePut) String() string {
+func (this *ImageUpdate) String() string {
 	if this == 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) + `,`,
-		`Labels:` + fmt.Sprintf("%v", this.Labels) + `,`,
+		`Labels:` + mapStringForLabels + `,`,
 		`}`,
 	}, "")
 	return s
@@ -186,7 +212,7 @@ func valueToStringImage(v interface{}) string {
 	pv := reflect.Indirect(rv).Interface()
 	return fmt.Sprintf("*%v", pv)
 }
-func (m *ImagePut) Unmarshal(dAtA []byte) error {
+func (m *ImageUpdate) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -209,10 +235,10 @@ func (m *ImagePut) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		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 {
-			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 {
 		case 1:
@@ -248,7 +274,7 @@ func (m *ImagePut) Unmarshal(dAtA []byte) error {
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
 			}
-			var stringLen uint64
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowImage
@@ -258,20 +284,107 @@ func (m *ImagePut) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
+			if msglen < 0 {
-			if intStringLen < 0 {
 				return ErrInvalidLengthImage
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + msglen
 			if postIndex > l {
 				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
 		default:
 			iNdEx = preIndex
@@ -483,16 +596,20 @@ func init() {
 }
 
 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,
 	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,
 	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,
 }

api/types/event/image.proto

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

client.go

@@ -180,7 +180,9 @@ func WithNewReadonlyRootFS(id string, i Image) NewContainerOpts {
 
 func WithRuntime(name string) NewContainerOpts {
 	return func(ctx context.Context, client *Client, c *containers.Container) error {
-		c.Runtime = name
+		c.Runtime = &containers.Container_Runtime{
+			Name: name,
+		}
 		return nil
 	}
 }
@@ -197,7 +199,9 @@ func WithImage(i Image) NewContainerOpts {
 func (c *Client) NewContainer(ctx context.Context, id string, opts ...NewContainerOpts) (Container, error) {
 	container := containers.Container{
 		ID: id,
-		Runtime: c.runtime,
+		Runtime: &containers.Container_Runtime{
+			Name: c.runtime,
+		},
 	}
 	for _, o := range opts {
 		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()
-	if err := is.Put(ctx, name, desc); err != nil {
+	if err := is.Update(ctx, name, desc); err != nil {
 		return nil, err
 	}
 	i, err := is.Get(ctx, name)
@@ -448,7 +452,7 @@ func (c *Client) ContentStore() content.Store {
 }
 
 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 {

client_test.go

@@ -27,7 +27,7 @@ var (
 )
 
 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.Parse()
 }
@@ -59,6 +59,7 @@ func TestMain(m *testing.M) {
 		cmd = exec.Command("containerd",
 			"--root", defaultRoot,
 			"--state", defaultState,
+			"--address", address,
 		)
 		cmd.Stderr = buf
 		if err := cmd.Start(); err != nil {

cmd/containerd/main.go

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

cmd/ctr/events.go

@@ -23,7 +23,7 @@ var eventsCommand = cli.Command{
 		ctx, cancel := appContext(context)
 		defer cancel()
 
-		events, err := eventsClient.EventStream(ctx, &eventsapi.EventStreamRequest{})
+		events, err := eventsClient.Stream(ctx, &eventsapi.StreamEventsRequest{})
 		if err != nil {
 			return err
 		}
@@ -114,8 +114,8 @@ func getEventOutput(evt *event.Envelope) (string, error) {
 			return out, err
 		}
 		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 {
 			return out, err
 		}

cmd/ctr/utils.go

@@ -21,7 +21,6 @@ import (
 	namespacesapi "github.com/containerd/containerd/api/services/namespaces"
 	snapshotapi "github.com/containerd/containerd/api/services/snapshot"
 	versionservice "github.com/containerd/containerd/api/services/version"
-	"github.com/containerd/containerd/api/types/task"
 	"github.com/containerd/containerd/content"
 	"github.com/containerd/containerd/images"
 	"github.com/containerd/containerd/namespaces"
@@ -112,7 +111,7 @@ func getSnapshotter(context *cli.Context) (snapshot.Snapshotter, error) {
 	if err != nil {
 		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) {
@@ -139,21 +138,6 @@ func getVersionService(context *cli.Context) (versionservice.VersionClient, erro
 	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 {
 	sigc := make(chan os.Signal, 128)
 	signal.Notify(sigc)

cmd/dist/rootfs.go

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

container.go

@@ -104,7 +104,7 @@ func (c *container) Image(ctx context.Context) (Image, error) {
 	}, 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) {
 	c.mu.Lock()
@@ -113,7 +113,7 @@ func (c *container) NewTask(ctx context.Context, ioCreate IOCreation, opts ...Ne
 	if err != nil {
 		return nil, err
 	}
-	request := &execution.CreateRequest{
+	request := &execution.CreateTaskRequest{
 		ContainerID: c.c.ID,
 		Terminal:    i.Terminal,
 		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) {
-	response, err := c.client.TaskService().Info(ctx, &execution.InfoRequest{
+	response, err := c.client.TaskService().Get(ctx, &execution.GetTaskRequest{
 		ContainerID: c.c.ID,
 	})
 	if err != nil {

container_test.go

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

container_unix.go

@@ -83,7 +83,7 @@ func WithCheckpoint(desc v1.Descriptor, rootfsID string) NewContainerOpts {
 }
 
 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
 		index, err := decodeIndex(ctx, c.ContentStore(), id)
 		if err != nil {

containers/containers.go

@@ -1,7 +1,10 @@
 package containers
 
 import (
+	"bytes"
 	"context"
+	"encoding/gob"
+	"errors"
 	"time"
 )
 
@@ -13,13 +16,35 @@ type Container struct {
 	ID        string
 	Labels    map[string]string
 	Image     string
-	Runtime   string
+	Runtime   RuntimeInfo
 	Spec      []byte
 	RootFS    string
 	CreatedAt 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 {
 	Get(ctx context.Context, id string) (Container, error)
 	List(ctx context.Context, filter string) ([]Container, error)

events/convert.go

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

images/image.go

@@ -18,7 +18,7 @@ type Image struct {
 }
 
 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)
 	List(ctx context.Context) ([]Image, error)
 	Delete(ctx context.Context, name string) error

linux/shim/init.go

@@ -254,19 +254,24 @@ func (p *initProcess) Stdin() io.Closer {
 
 func (p *initProcess) Checkpoint(context context.Context, r *shimapi.CheckpointRequest) error {
 	var actions []runc.CheckpointAction
+	/*
 		if !r.Exit {
 			actions = append(actions, runc.LeaveRunning)
 		}
+	*/
 	work := filepath.Join(p.bundle, "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{
 		WorkDir:   work,
-		ImagePath:                r.CheckpointPath,
+		ImagePath: r.Path,
+		/*
 			AllowOpenTCP:             r.AllowTcp,
 			AllowExternalUnixSockets: r.AllowUnixSockets,
 			AllowTerminal:            r.AllowTerminal,
 			FileLocks:                r.FileLocks,
 			EmptyNamespaces:          r.EmptyNamespaces,
+		*/
 	}, actions...); err != nil {
 		dumpLog := filepath.Join(p.bundle, "criu-dump.log")
 		if cerr := copyFile(dumpLog, filepath.Join(work, "dump.log")); cerr != nil {

linux/task.go

@@ -165,20 +165,15 @@ func (t *Task) CloseStdin(ctx context.Context, pid uint32) error {
 	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) {

metadata/containers.go

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

metadata/images.go

@@ -46,7 +46,7 @@ func (s *imageStore) Get(ctx context.Context, name string) (images.Image, error)
 	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)
 	if err != nil {
 		return err

plugin/container.go

@@ -32,21 +32,11 @@ type Task interface {
 	// CloseStdin closes the processes stdin
 	CloseStdin(context.Context, uint32) error
 	// 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(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 {
 	Spec []byte
 	IO   IO

process.go

@@ -3,10 +3,10 @@ package containerd
 import (
 	"context"
 	"encoding/json"
+	"fmt"
 	"syscall"
 
 	"github.com/containerd/containerd/api/services/execution"
-	taskapi "github.com/containerd/containerd/api/types/task"
 	protobuf "github.com/gogo/protobuf/types"
 	specs "github.com/opencontainers/runtime-spec/specs-go"
 )
@@ -38,7 +38,7 @@ func (p *process) Start(ctx context.Context) error {
 	if err != nil {
 		return err
 	}
-	request := &execution.ExecRequest{
+	request := &execution.ExecProcessRequest{
 		ContainerID: p.task.containerID,
 		Terminal:    p.io.Terminal,
 		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) {
-	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,
 		Pid:         p.pid,
-	})
+	}
+	for _, o := range opts {
+		o(r)
+	}
+	_, err := p.task.client.TaskService().CloseIO(ctx, r)
 	return err
 }
 
@@ -102,7 +90,7 @@ func (p *process) IO() *IO {
 }
 
 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,
 		Width:       w,
 		Height:      h,

services/containers/helpers.go

@@ -25,7 +25,10 @@ func containerToProto(container *containers.Container) api.Container {
 		ID:     container.ID,
 		Labels: container.Labels,
 		Image:  container.Image,
-		Runtime: container.Runtime,
+		Runtime: &api.Container_Runtime{
+			Name:    container.Runtime.Name,
+			Options: container.Runtime.Options,
+		},
 		Spec: &types.Any{
 			TypeUrl: specs.Version,
 			Value:   container.Spec,
@@ -39,7 +42,10 @@ func containerFromProto(containerpb *api.Container) containers.Container {
 		ID:     containerpb.ID,
 		Labels: containerpb.Labels,
 		Image:  containerpb.Image,
-		Runtime: containerpb.Runtime,
+		Runtime: containers.RuntimeInfo{
+			Name:    containerpb.Runtime.Name,
+			Options: containerpb.Runtime.Options,
+		},
 		Spec:   containerpb.Spec.Value,
 		RootFS: containerpb.RootFS,
 	}

services/containers/service.go

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

services/content/reader.go

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

services/content/service.go

@@ -137,7 +137,7 @@ func (s *Service) Delete(ctx context.Context, req *api.DeleteContentRequest) (*e
 	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 {
 		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
 }
 
-// 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
 // into the buffer size.
@@ -203,7 +203,7 @@ type readResponseWriter struct {
 }
 
 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,
 		Data:   p,
 	}); 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) {
-	statuses, err := s.store.Status(ctx, req.Regexp)
+	statuses, err := s.store.Status(ctx, req.Filter)
 	if err != nil {
-		return nil, serverErrorToGRPC(err, req.Regexp)
+		return nil, serverErrorToGRPC(err, req.Filter)
 	}
 
 	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) {
 	var (
 		ctx      = session.Context()
-		msg      api.WriteResponse
+		msg      api.WriteContentResponse
-		req      *api.WriteRequest
+		req      *api.WriteContentRequest
 		ref      string
 		total    int64
 		expected digest.Digest
 	)
 
-	defer func(msg *api.WriteResponse) {
+	defer func(msg *api.WriteContentResponse) {
 		// pump through the last message if no error was encountered
 		if err != nil {
 			if grpc.Code(err) != codes.AlreadyExists {

services/content/store.go

@@ -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) {
-	client, err := rs.client.Read(ctx, &contentapi.ReadRequest{Digest: dgst})
+	client, err := rs.client.Read(ctx, &contentapi.ReadContentRequest{Digest: dgst})
 	if err != nil {
 		return nil, err
 	}
@@ -93,9 +93,9 @@ func (rs *remoteStore) ReaderAt(ctx context.Context, dgst digest.Digest) (io.Rea
 	}, 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{
-		Regexp: re,
+		Filter: filter,
 	})
 	if err != nil {
 		return nil, rewriteGRPCError(err)
@@ -146,7 +146,7 @@ func (rs *remoteStore) negotiate(ctx context.Context, ref string, size int64, ex
 		return nil, 0, err
 	}
 
-	if err := wrclient.Send(&contentapi.WriteRequest{
+	if err := wrclient.Send(&contentapi.WriteContentRequest{
 		Action:   contentapi.WriteActionStat,
 		Ref:      ref,
 		Total:    size,

services/content/writer.go

@@ -17,7 +17,7 @@ type remoteWriter struct {
 }
 
 // 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 {
 		return nil, err
 	}
@@ -35,7 +35,7 @@ func (rw *remoteWriter) send(req *contentapi.WriteRequest) (*contentapi.WriteRes
 }
 
 func (rw *remoteWriter) Status() (content.Status, error) {
-	resp, err := rw.send(&contentapi.WriteRequest{
+	resp, err := rw.send(&contentapi.WriteContentRequest{
 		Action: contentapi.WriteActionStat,
 	})
 	if err != nil {
@@ -57,7 +57,7 @@ func (rw *remoteWriter) Digest() digest.Digest {
 func (rw *remoteWriter) Write(p []byte) (n int, err error) {
 	offset := rw.offset
 
-	resp, err := rw.send(&contentapi.WriteRequest{
+	resp, err := rw.send(&contentapi.WriteContentRequest{
 		Action: contentapi.WriteActionWrite,
 		Offset: offset,
 		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 {
-	resp, err := rw.send(&contentapi.WriteRequest{
+	resp, err := rw.send(&contentapi.WriteContentRequest{
 		Action:   contentapi.WriteActionCommit,
 		Total:    size,
 		Offset:   rw.offset,

services/events/service.go

@@ -35,7 +35,7 @@ func (s *Service) Register(server *grpc.Server) error {
 	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())
 	for {
 		e := <-s.emitter.Events(srv.Context(), clientID)

services/execution/collector.go

@@ -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)
-}

services/execution/service.go

@@ -67,15 +67,10 @@ func New(ic *plugin.InitContext) (interface{}, error) {
 		r := rr.(plugin.Runtime)
 		runtimes[r.ID()] = r
 	}
-	c, err := newCollector(ic.Context, runtimes)
-	if err != nil {
-		return nil, err
-	}
 	e := events.GetPoster(ic.Context)
 	return &Service{
 		runtimes: runtimes,
 		db:       m.(*bolt.DB),
-		collector: c,
 		store:    ct.(content.Store),
 		emitter:  e,
 	}, nil
@@ -84,7 +79,6 @@ func New(ic *plugin.InitContext) (interface{}, error) {
 type Service struct {
 	runtimes map[string]plugin.Runtime
 	db       *bolt.DB
-	collector *collector
 	store    content.Store
 	emitter  events.Poster
 }
@@ -94,7 +88,7 @@ func (s *Service) Register(server *grpc.Server) error {
 	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 (
 		checkpointPath string
 		err            error
@@ -152,7 +146,7 @@ func (s *Service) Create(ctx context.Context, r *api.CreateRequest) (*api.Create
 			Options: m.Options,
 		})
 	}
-	runtime, err := s.getRuntime(container.Runtime)
+	runtime, err := s.getRuntime(container.Runtime.Name)
 	if err != nil {
 		return nil, err
 	}
@@ -171,13 +165,13 @@ func (s *Service) Create(ctx context.Context, r *api.CreateRequest) (*api.Create
 		return nil, err
 	}
 
-	return &api.CreateResponse{
+	return &api.CreateTaskResponse{
 		ContainerID: r.ContainerID,
 		Pid:         state.Pid,
 	}, 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)
 	if err != nil {
 		return nil, err
@@ -195,7 +189,7 @@ func (s *Service) Start(ctx context.Context, r *api.StartRequest) (*google_proto
 	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)
 	if err != nil {
 		return nil, err
@@ -271,7 +265,7 @@ func taskFromContainerd(ctx context.Context, c plugin.Task) (*task.Task, error)
 	}, 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)
 	if err != nil {
 		return nil, err
@@ -280,13 +274,13 @@ func (s *Service) Info(ctx context.Context, r *api.InfoRequest) (*api.InfoRespon
 	if err != nil {
 		return nil, err
 	}
-	return &api.InfoResponse{
+	return &api.GetTaskResponse{
 		Task: t,
 	}, 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 {
 		tasks, err := r.Tasks(ctx)
 		if err != nil {
@@ -303,7 +297,7 @@ func (s *Service) List(ctx context.Context, r *api.ListRequest) (*api.ListRespon
 	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)
 	if err != nil {
 		return nil, err
@@ -315,7 +309,7 @@ func (s *Service) Pause(ctx context.Context, r *api.PauseRequest) (*google_proto
 	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)
 	if err != nil {
 		return nil, err
@@ -348,7 +342,7 @@ func (s *Service) Kill(ctx context.Context, r *api.KillRequest) (*google_protobu
 	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)
 	if err != nil {
 		return nil, err
@@ -365,22 +359,12 @@ func (s *Service) Processes(ctx context.Context, r *api.ProcessesRequest) (*api.
 			Pid: pid,
 		})
 	}
-
+	return &api.ListProcessesResponse{
-	resp := &api.ProcessesResponse{
 		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)
 	if err != nil {
 		return nil, err
@@ -401,12 +385,12 @@ func (s *Service) Exec(ctx context.Context, r *api.ExecRequest) (*api.ExecRespon
 	if err != nil {
 		return nil, err
 	}
-	return &api.ExecResponse{
+	return &api.ExecProcessResponse{
 		Pid: state.Pid,
 	}, 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)
 	if err != nil {
 		return nil, err
@@ -420,18 +404,20 @@ func (s *Service) Pty(ctx context.Context, r *api.PtyRequest) (*google_protobuf.
 	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)
 	if err != nil {
 		return nil, err
 	}
+	if r.Stdin {
 		if err := t.CloseStdin(ctx, r.Pid); err != nil {
 			return nil, err
 		}
+	}
 	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)
 	if err != nil {
 		return nil, err
@@ -441,16 +427,7 @@ func (s *Service) Checkpoint(ctx context.Context, r *api.CheckpointRequest) (*ap
 		return nil, err
 	}
 	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
 	}
 	// write checkpoint to the content store
@@ -469,7 +446,7 @@ func (s *Service) Checkpoint(ctx context.Context, r *api.CheckpointRequest) (*ap
 	if err != nil {
 		return nil, err
 	}
-	return &api.CheckpointResponse{
+	return &api.CheckpointTaskResponse{
 		Descriptors: []*descriptor.Descriptor{
 			cp,
 			specD,
@@ -523,31 +500,3 @@ func (s *Service) emit(ctx context.Context, topic string, evt interface{}) error
 
 	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,
-	})
-}

services/images/client.go

@@ -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
 	// a modified image.
-	_, err := s.client.Put(ctx, &imagesapi.PutRequest{
+	_, err := s.client.Update(ctx, &imagesapi.UpdateImageRequest{
 		Image: imagesapi.Image{
 			Name:   name,
 			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) {
-	resp, err := s.client.Get(ctx, &imagesapi.GetRequest{
+	resp, err := s.client.Get(ctx, &imagesapi.GetImageRequest{
 		Name: name,
 	})
 	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) {
-	resp, err := s.client.List(ctx, &imagesapi.ListRequest{})
+	resp, err := s.client.List(ctx, &imagesapi.ListImagesRequest{})
 	if err != nil {
 		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 {
-	_, err := s.client.Delete(ctx, &imagesapi.DeleteRequest{
+	_, err := s.client.Delete(ctx, &imagesapi.DeleteImageRequest{
 		Name: name,
 	})
 

services/images/service.go

@@ -48,8 +48,8 @@ func (s *Service) Register(server *grpc.Server) error {
 	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 {
 		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 {
-		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 {
-		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,
 		Labels: req.Image.Labels,
 	}); 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 {
 		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 {
 		return mapGRPCError(store.Delete(ctx, req.Name), req.Name)
 	}); err != nil {
-		return &empty.Empty{}, err
+		return nil, err
 	}
 
 	if err := s.emit(ctx, "/images/delete", event.ImageDelete{
 		Name: req.Name,
 	}); err != nil {
-		return &empty.Empty{}, err
+		return nil, err
 	}
 
 	return &empty.Empty{}, nil

services/snapshot/client.go

@@ -9,6 +9,7 @@ import (
 	"google.golang.org/grpc/codes"
 
 	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/snapshot"
 	"github.com/pkg/errors"
@@ -16,18 +17,18 @@ import (
 
 // NewSnapshotterFromClient returns a new Snapshotter which communicates
 // over a GRPC connection.
-func NewSnapshotterFromClient(client snapshotapi.SnapshotClient) snapshot.Snapshotter {
+func NewSnapshotterFromClient(client snapshotapi.SnapshotsClient) snapshot.Snapshotter {
 	return &remoteSnapshotter{
 		client: client,
 	}
 }
 
 type remoteSnapshotter struct {
-	client snapshotapi.SnapshotClient
+	client snapshotapi.SnapshotsClient
 }
 
 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 {
 		return snapshot.Info{}, rewriteGRPCError(err)
 	}
@@ -47,27 +48,27 @@ func (r *remoteSnapshotter) Mounts(ctx context.Context, key string) ([]mount.Mou
 	if err != nil {
 		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) {
-	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 {
 		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) {
-	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 {
 		return nil, rewriteGRPCError(err)
 	}
-	return toMounts(resp), nil
+	return toMounts(resp.Mounts), nil
 }
 
 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,
 		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 {
-	_, err := r.client.Remove(ctx, &snapshotapi.RemoveRequest{Key: key})
+	_, err := r.client.Remove(ctx, &snapshotapi.RemoveSnapshotRequest{Key: key})
 	return rewriteGRPCError(err)
 }
 
 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 {
 		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{
 			Type:    m.Type,
 			Source:  m.Source,

services/snapshot/service.go

@@ -50,11 +50,11 @@ func newService(snapshotter snapshot.Snapshotter, evts events.Poster) (*service,
 }
 
 func (s *service) Register(gs *grpc.Server) error {
-	snapshotapi.RegisterSnapshotServer(gs, s)
+	snapshotapi.RegisterSnapshotsServer(gs, s)
 	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")
 	// TODO: Apply namespace
 	// TODO: Lookup snapshot id from metadata store
@@ -69,11 +69,12 @@ func (s *service) Prepare(ctx context.Context, pr *snapshotapi.PrepareRequest) (
 	}); err != nil {
 		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")
 	// TODO: Apply namespace
 	// 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 {
 		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) {
@@ -92,10 +95,12 @@ func (s *service) Mounts(ctx context.Context, mr *snapshotapi.MountsRequest) (*s
 	if err != nil {
 		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")
 	// TODO: Apply namespace
 	// 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
 }
 
-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")
 	// TODO: Apply namespace
 	// 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
 }
 
-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")
 	// TODO: Apply namespace
 	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 &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
-
 	var (
 		buffer    []snapshotapi.Info
 		sendBlock = func(block []snapshotapi.Info) error {
-			return ss.Send(&snapshotapi.ListResponse{
+			return ss.Send(&snapshotapi.ListSnapshotsResponse{
 				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 {
-		resp.Mounts[i] = &mounttypes.Mount{
+		out[i] = &mounttypes.Mount{
 			Type:    m.Type,
 			Source:  m.Source,
 			Options: m.Options,
 		}
 	}
-	return resp
+	return out
 }
 
 func (s *service) emit(ctx context.Context, topic string, evt interface{}) error {

task.go

@@ -12,7 +12,6 @@ import (
 
 	"github.com/containerd/containerd/api/services/containers"
 	"github.com/containerd/containerd/api/services/execution"
-	taskapi "github.com/containerd/containerd/api/types/task"
 	"github.com/containerd/containerd/content"
 	"github.com/containerd/containerd/rootfs"
 	"github.com/opencontainers/image-spec/specs-go/v1"
@@ -31,7 +30,13 @@ const (
 	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 {
 	Pid() uint32
@@ -44,7 +49,7 @@ type Task interface {
 	Wait(context.Context) (uint32, error)
 	Exec(context.Context, *specs.Process, IOCreation) (Process, error)
 	Processes(context.Context) ([]uint32, error)
-	CloseStdin(context.Context) error
+	CloseIO(context.Context, ...IOCloserOpts) error
 	Resize(ctx context.Context, w, h uint32) error
 	IO() *IO
 	Checkpoint(context.Context, ...CheckpointOpts) (v1.Descriptor, error)
@@ -56,7 +61,7 @@ type Process interface {
 	Delete(context.Context) (uint32, error)
 	Kill(context.Context, syscall.Signal) error
 	Wait(context.Context) (uint32, error)
-	CloseStdin(context.Context) error
+	CloseIO(context.Context, ...IOCloserOpts) error
 	Resize(ctx context.Context, w, h uint32) error
 	IO() *IO
 }
@@ -70,7 +75,7 @@ type task struct {
 	containerID string
 	pid         uint32
 
-	deferred *execution.CreateRequest
+	deferred *execution.CreateTaskRequest
 	pidSync  chan struct{}
 }
 
@@ -90,7 +95,7 @@ func (t *task) Start(ctx context.Context) error {
 		close(t.pidSync)
 		return nil
 	}
-	_, err := t.client.TaskService().Start(ctx, &execution.StartRequest{
+	_, err := t.client.TaskService().Start(ctx, &execution.StartTaskRequest{
 		ContainerID: t.containerID,
 	})
 	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 {
-	_, err := t.client.TaskService().Pause(ctx, &execution.PauseRequest{
+	_, err := t.client.TaskService().Pause(ctx, &execution.PauseTaskRequest{
 		ContainerID: t.containerID,
 	})
 	return err
 }
 
 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,
 	})
 	return err
 }
 
 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,
 	})
 	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
 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
@@ -160,7 +149,7 @@ func (t *task) Delete(ctx context.Context) (uint32, error) {
 	if t.io != nil {
 		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,
 	})
 	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) {
-	response, err := t.client.TaskService().Processes(ctx, &execution.ProcessesRequest{
+	response, err := t.client.TaskService().ListProcesses(ctx, &execution.ListProcessesRequest{
 		ContainerID: t.containerID,
 	})
 	if err != nil {
@@ -196,11 +185,15 @@ func (t *task) Processes(ctx context.Context) ([]uint32, error) {
 	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,
 		Pid:         t.pid,
-	})
+	}
+	for _, o := range opts {
+		o(r)
+	}
+	_, err := t.client.TaskService().CloseIO(ctx, r)
 	return err
 }
 
@@ -209,7 +202,7 @@ func (t *task) IO() *IO {
 }
 
 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,
 		Width:       w,
 		Height:      h,
@@ -218,28 +211,26 @@ func (t *task) Resize(ctx context.Context, w, h uint32) error {
 	return err
 }
 
-func WithExit(r *execution.CheckpointRequest) error {
+func WithExit(r *execution.CheckpointTaskRequest) error {
-	r.Exit = true
+	r.Options["exit"] = "true"
 	return nil
 }
 
 func (t *task) Checkpoint(ctx context.Context, opts ...CheckpointOpts) (d v1.Descriptor, err error) {
-	request := &execution.CheckpointRequest{
+	request := &execution.CheckpointTaskRequest{
 		ContainerID: t.containerID,
+		Options:     make(map[string]string),
 	}
 	for _, o := range opts {
 		if err := o(request); err != nil {
 			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 !request.Exit {
 	if err := t.Pause(ctx); err != nil {
 		return d, err
 	}
 	defer t.Resume(ctx)
-	}
 	cr, err := t.client.ContainerService().Get(ctx, &containers.GetContainerRequest{
 		ID: t.containerID,
 	})
@@ -261,7 +252,7 @@ func (t *task) Checkpoint(ctx context.Context, opts ...CheckpointOpts) (d v1.Des
 	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)
 	if err != nil {
 		return err