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

Implement options for runtime specific settings

Browse Source 
Signed-off-by: Michael Crosby <crosbymichael@gmail.com>
This commit is contained in:
Michael Crosby
2017-06-23 14:55:10 -07:00
parent eedcbc64cc
commit 82d0208aaa
18 changed files with 1701 additions and 467 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
linux/runcopts/options.go Normal file
View File

@@ -0,0 +1,3 @@
package runcopts
const URIBase = "containerd.io/linux/runc"

1153
linux/runcopts/runc.pb.go Normal file
View File

File diff suppressed because it is too large Load Diff

33
linux/runcopts/runc.proto Normal file
View File

@@ -0,0 +1,33 @@
syntax = "proto3";
package containerd.linux.runc;
import "gogoproto/gogo.proto";
option go_package = "github.com/containerd/containerd/linux/runcopts;runcopts";
message RuncOptions {
string criu_path = 1;
string systemd_cgroup = 2;
}
message CreateOptions {
bool no_pivot_root = 1;
bool open_tcp = 2;
bool external_unix_sockets = 3;
bool terminal = 4;
bool file_locks = 5;
repeated string empty_namespaces = 6;
string cgroups_mode = 7;
bool no_new_keyring = 8;
}
message CheckpointOptions {
bool exit = 1;
bool open_tcp = 2;
bool external_unix_sockets = 3;
bool terminal = 4;
bool file_locks = 5;
repeated string empty_namespaces = 6;
string cgroups_mode = 7;
}

4
linux/runtime.go
View File

@@ -25,6 +25,7 @@ import (
"github.com/containerd/containerd/plugin"
"github.com/containerd/containerd/runtime"
runc "github.com/containerd/go-runc"
protobuf "github.com/gogo/protobuf/types"
google_protobuf "github.com/golang/protobuf/ptypes/empty"
"github.com/pkg/errors"
@@ -171,6 +172,9 @@ func (r *Runtime) Create(ctx context.Context, id string, opts runtime.CreateOpts
Stderr: opts.IO.Stderr,
Terminal: opts.IO.Terminal,
Checkpoint: opts.Checkpoint,
Options: &protobuf.Any{
Value: opts.Options,
},
}
for _, m := range opts.Rootfs {
sopts.Rootfs = append(sopts.Rootfs, &types.Mount{

53
linux/shim/init.go
View File

@@ -17,12 +17,14 @@ import (
"golang.org/x/sys/unix"
"github.com/containerd/console"
"github.com/containerd/containerd/linux/runcopts"
shimapi "github.com/containerd/containerd/linux/shim/v1"
"github.com/containerd/containerd/log"
"github.com/containerd/containerd/mount"
"github.com/containerd/containerd/runtime"
"github.com/containerd/fifo"
runc "github.com/containerd/go-runc"
"github.com/gogo/protobuf/proto"
specs "github.com/opencontainers/runtime-spec/specs-go"
"github.com/pkg/errors"
)
@@ -54,6 +56,12 @@ type initProcess struct {
}
func newInitProcess(context context.Context, path, namespace string, r *shimapi.CreateTaskRequest) (*initProcess, error) {
var options runcopts.CreateOptions
if r.Options != nil {
if err := proto.Unmarshal(r.Options.Value, &options); err != nil {
return nil, err
}
}
for _, rm := range r.Rootfs {
m := &mount.Mount{
Type: rm.Type,
@@ -105,10 +113,9 @@ func newInitProcess(context context.Context, path, namespace string, r *shimapi.
WorkDir: filepath.Join(r.Bundle, "work"),
ParentPath: r.ParentCheckpoint,
},
PidFile: pidFile,
IO: io,
// TODO: implement runtime options
//NoPivot: r.NoPivot,
PidFile: pidFile,
IO: io,
NoPivot: options.NoPivotRoot,
Detach: true,
NoSubreaper: true,
}
@@ -117,9 +124,10 @@ func newInitProcess(context context.Context, path, namespace string, r *shimapi.
}
} else {
opts := &runc.CreateOpts{
PidFile: pidFile,
IO: io,
// NoPivot: r.NoPivot,
PidFile: pidFile,
IO: io,
NoPivot: options.NoPivotRoot,
NoNewKeyring: options.NoNewKeyring,
}
if socket != nil {
opts.ConsoleSocket = socket
@@ -256,25 +264,26 @@ func (p *initProcess) Stdin() io.Closer {
}
func (p *initProcess) Checkpoint(context context.Context, r *shimapi.CheckpointTaskRequest) error {
var actions []runc.CheckpointAction
/*
if !r.Exit {
actions = append(actions, runc.LeaveRunning)
var options runcopts.CheckpointOptions
if r.Options != nil {
if err := proto.Unmarshal(r.Options.Value, &options); err != nil {
return err
}
*/
}
var actions []runc.CheckpointAction
if !options.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.Path,
/*
AllowOpenTCP: r.AllowTcp,
AllowExternalUnixSockets: r.AllowUnixSockets,
AllowTerminal: r.AllowTerminal,
FileLocks: r.FileLocks,
EmptyNamespaces: r.EmptyNamespaces,
*/
WorkDir: work,
ImagePath: r.Path,
AllowOpenTCP: options.OpenTcp,
AllowExternalUnixSockets: options.ExternalUnixSockets,
AllowTerminal: options.Terminal,
FileLocks: options.FileLocks,
EmptyNamespaces: options.EmptyNamespaces,
}, actions...); err != nil {
dumpLog := filepath.Join(p.bundle, "criu-dump.log")
if cerr := copyFile(dumpLog, filepath.Join(work, "dump.log")); cerr != nil {

360
linux/shim/v1/shim.pb.go
View File

@@ -50,7 +50,6 @@ 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"
@@ -77,6 +76,7 @@ type CreateTaskRequest struct {
Stderr string `protobuf:"bytes,8,opt,name=stderr,proto3" json:"stderr,omitempty"`
Checkpoint string `protobuf:"bytes,9,opt,name=checkpoint,proto3" json:"checkpoint,omitempty"`
ParentCheckpoint string `protobuf:"bytes,10,opt,name=parent_checkpoint,json=parentCheckpoint,proto3" json:"parent_checkpoint,omitempty"`
Options *google_protobuf.Any `protobuf:"bytes,11,opt,name=options" json:"options,omitempty"`
}
func (m *CreateTaskRequest) Reset() { *m = CreateTaskRequest{} }
@@ -191,8 +191,8 @@ func (*ListPidsResponse) ProtoMessage() {}
func (*ListPidsResponse) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{11} }
type CheckpointTaskRequest struct {
Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,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"`
Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
Options *google_protobuf.Any `protobuf:"bytes,2,opt,name=options" json:"options,omitempty"`
}
func (m *CheckpointTaskRequest) Reset() { *m = CheckpointTaskRequest{} }
@@ -925,6 +925,16 @@ func (m *CreateTaskRequest) MarshalTo(dAtA []byte) (int, error) {
i = encodeVarintShim(dAtA, i, uint64(len(m.ParentCheckpoint)))
i += copy(dAtA[i:], m.ParentCheckpoint)
}
if m.Options != nil {
dAtA[i] = 0x5a
i++
i = encodeVarintShim(dAtA, i, uint64(m.Options.Size()))
n1, err := m.Options.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n1
}
return i, nil
}
@@ -979,11 +989,11 @@ func (m *DeleteResponse) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x1a
i++
i = encodeVarintShim(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.ExitedAt)))
n1, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ExitedAt, dAtA[i:])
n2, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ExitedAt, dAtA[i:])
if err != nil {
return 0, err
}
i += n1
i += n2
return i, nil
}
@@ -1057,11 +1067,11 @@ func (m *ExecProcessRequest) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x2a
i++
i = encodeVarintShim(dAtA, i, uint64(m.Spec.Size()))
n2, err := m.Spec.MarshalTo(dAtA[i:])
n3, err := m.Spec.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n2
i += n3
}
return i, nil
}
@@ -1313,21 +1323,21 @@ func (m *ListPidsResponse) MarshalTo(dAtA []byte) (int, error) {
var l int
_ = l
if len(m.Pids) > 0 {
dAtA4 := make([]byte, len(m.Pids)*10)
var j3 int
dAtA5 := make([]byte, len(m.Pids)*10)
var j4 int
for _, num := range m.Pids {
for num >= 1<<7 {
dAtA4[j3] = uint8(uint64(num)&0x7f | 0x80)
dAtA5[j4] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j3++
j4++
}
dAtA4[j3] = uint8(num)
j3++
dAtA5[j4] = uint8(num)
j4++
}
dAtA[i] = 0xa
i++
i = encodeVarintShim(dAtA, i, uint64(j3))
i += copy(dAtA[i:], dAtA4[:j3])
i = encodeVarintShim(dAtA, i, uint64(j4))
i += copy(dAtA[i:], dAtA5[:j4])
}
return i, nil
}
@@ -1353,22 +1363,15 @@ func (m *CheckpointTaskRequest) MarshalTo(dAtA []byte) (int, error) {
i = encodeVarintShim(dAtA, i, uint64(len(m.Path)))
i += copy(dAtA[i:], m.Path)
}
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.Options != nil {
dAtA[i] = 0x12
i++
i = encodeVarintShim(dAtA, i, uint64(m.Options.Size()))
n6, err := m.Options.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n6
}
return i, nil
}
@@ -1433,11 +1436,11 @@ func (m *UpdateTaskRequest) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0xa
i++
i = encodeVarintShim(dAtA, i, uint64(m.Resources.Size()))
n5, err := m.Resources.MarshalTo(dAtA[i:])
n7, err := m.Resources.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n5
i += n7
}
return i, nil
}
@@ -1513,6 +1516,10 @@ func (m *CreateTaskRequest) Size() (n int) {
if l > 0 {
n += 1 + l + sovShim(uint64(l))
}
if m.Options != nil {
l = m.Options.Size()
n += 1 + l + sovShim(uint64(l))
}
return n
}
@@ -1695,13 +1702,9 @@ func (m *CheckpointTaskRequest) Size() (n int) {
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))
}
if m.Options != nil {
l = m.Options.Size()
n += 1 + l + sovShim(uint64(l))
}
return n
}
@@ -1759,6 +1762,7 @@ func (this *CreateTaskRequest) String() string {
`Stderr:` + fmt.Sprintf("%v", this.Stderr) + `,`,
`Checkpoint:` + fmt.Sprintf("%v", this.Checkpoint) + `,`,
`ParentCheckpoint:` + fmt.Sprintf("%v", this.ParentCheckpoint) + `,`,
`Options:` + strings.Replace(fmt.Sprintf("%v", this.Options), "Any", "google_protobuf.Any", 1) + `,`,
`}`,
}, "")
return s
@@ -1896,19 +1900,9 @@ func (this *CheckpointTaskRequest) 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{`&CheckpointTaskRequest{`,
`Path:` + fmt.Sprintf("%v", this.Path) + `,`,
`Options:` + mapStringForOptions + `,`,
`Options:` + strings.Replace(fmt.Sprintf("%v", this.Options), "Any", "google_protobuf.Any", 1) + `,`,
`}`,
}, "")
return s
@@ -2262,6 +2256,39 @@ func (m *CreateTaskRequest) Unmarshal(dAtA []byte) error {
}
m.ParentCheckpoint = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 11:
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 ErrIntOverflowShim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthShim
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Options == nil {
m.Options = &google_protobuf.Any{}
}
if err := m.Options.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipShim(dAtA[iNdEx:])
@@ -3661,94 +3688,11 @@ func (m *CheckpointTaskRequest) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
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)
m.Options = &google_protobuf.Any{}
}
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
if err := m.Options.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
@@ -4084,77 +4028,75 @@ func init() {
}
var fileDescriptorShim = []byte{
// 1148 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0x4f, 0x73, 0xdb, 0x44,
0x14, 0xaf, 0x6c, 0x47, 0xb1, 0x9f, 0x71, 0x48, 0xb6, 0x69, 0x50, 0x5d, 0xc6, 0xc9, 0xe8, 0x50,
0xcc, 0x74, 0x2a, 0x35, 0x0e, 0x6d, 0x43, 0x38, 0xe5, 0xdf, 0x30, 0x19, 0xc8, 0xd4, 0xa3, 0xb4,
0x30, 0xc3, 0x0c, 0x64, 0x14, 0x6b, 0x63, 0xef, 0x44, 0x96, 0x54, 0xed, 0xca, 0xc4, 0x9c, 0x38,
0x71, 0xe6, 0x23, 0x70, 0xe0, 0xc6, 0x67, 0xe0, 0x4c, 0x8e, 0x1c, 0x39, 0x15, 0x9a, 0x4f, 0xc2,
0xec, 0x6a, 0x15, 0xc9, 0x76, 0x84, 0xed, 0x0e, 0x97, 0x78, 0xdf, 0xee, 0xfb, 0xbd, 0x7d, 0xfb,
0x7b, 0xff, 0x14, 0xf8, 0xb4, 0x4b, 0x58, 0x2f, 0x3a, 0x33, 0x3a, 0x7e, 0xdf, 0xec, 0xf8, 0x1e,
0xb3, 0x89, 0x87, 0x43, 0x27, 0xbb, 0x74, 0x89, 0x17, 0x5d, 0x9a, 0xb4, 0x47, 0xfa, 0xe6, 0x60,
0x53, 0xfc, 0x1a, 0x41, 0xe8, 0x33, 0x1f, 0x6d, 0xa4, 0x4a, 0x46, 0x18, 0x79, 0x8c, 0xf4, 0xb1,
0x21, 0x94, 0x0d, 0xa1, 0x34, 0xd8, 0xac, 0xdf, 0xef, 0xfa, 0x7e, 0xd7, 0xc5, 0xa6, 0xd0, 0x3f,
0x8b, 0xce, 0x4d, 0xdb, 0x1b, 0xc6, 0xe0, 0xfa, 0x83, 0xf1, 0x23, 0xdc, 0x0f, 0x58, 0x72, 0xb8,
0xda, 0xf5, 0xbb, 0xbe, 0x58, 0x9a, 0x7c, 0x25, 0x77, 0xd7, 0xc7, 0x21, 0xfc, 0x46, 0xca, 0xec,
0x7e, 0x20, 0x15, 0x9e, 0x4d, 0x7d, 0x8b, 0x1d, 0x10, 0x93, 0x0d, 0x03, 0x4c, 0xcd, 0xbe, 0x1f,
0x79, 0x4c, 0xe2, 0x76, 0xe6, 0xc0, 0x31, 0x9b, 0x5e, 0x88, 0x3f, 0x12, 0x7b, 0x38, 0x13, 0x96,
0xe2, 0x70, 0x40, 0x3a, 0x98, 0x9a, 0x78, 0x80, 0x3d, 0x46, 0x39, 0x91, 0x09, 0x63, 0xc2, 0x8c,
0xfe, 0x7b, 0x01, 0x56, 0xf6, 0x43, 0x6c, 0x33, 0xfc, 0xd2, 0xa6, 0x17, 0x16, 0x7e, 0x1d, 0x61,
0xca, 0xd0, 0x1a, 0x14, 0x88, 0xa3, 0x29, 0x1b, 0x4a, 0xb3, 0xb2, 0xa7, 0x5e, 0xbf, 0x59, 0x2f,
0x1c, 0x1d, 0x58, 0x05, 0xe2, 0xa0, 0x35, 0x50, 0xcf, 0x22, 0xcf, 0x71, 0xb1, 0x56, 0xe0, 0x67,
0x96, 0x94, 0x90, 0x06, 0x8b, 0xd2, 0xac, 0x56, 0x14, 0x07, 0x89, 0x88, 0x4c, 0x50, 0x43, 0xdf,
0x67, 0xe7, 0x54, 0x2b, 0x6d, 0x14, 0x9b, 0xd5, 0xd6, 0x07, 0x46, 0x26, 0x78, 0xe2, 0x65, 0xc6,
0x31, 0x67, 0xc4, 0x92, 0x6a, 0xa8, 0x0e, 0x65, 0x86, 0xc3, 0x3e, 0xf1, 0x6c, 0x57, 0x5b, 0xd8,
0x50, 0x9a, 0x65, 0xeb, 0x46, 0x46, 0xab, 0xb0, 0x40, 0x99, 0x43, 0x3c, 0x4d, 0x15, 0x97, 0xc4,
0x02, 0x77, 0x8a, 0x32, 0xc7, 0x8f, 0x98, 0xb6, 0x18, 0x3b, 0x15, 0x4b, 0x72, 0x1f, 0x87, 0xa1,
0x56, 0xbe, 0xd9, 0xc7, 0x61, 0x88, 0x1a, 0x00, 0x9d, 0x1e, 0xee, 0x5c, 0x04, 0x3e, 0xf1, 0x98,
0x56, 0x11, 0x67, 0x99, 0x1d, 0xf4, 0x08, 0x56, 0x02, 0x3b, 0xc4, 0x1e, 0x3b, 0xcd, 0xa8, 0x81,
0x50, 0x5b, 0x8e, 0x0f, 0xf6, 0x6f, 0xf6, 0xf5, 0x87, 0x80, 0xb2, 0xf4, 0xd1, 0xc0, 0xf7, 0x28,
0x46, 0xcb, 0x50, 0x0c, 0x24, 0x81, 0x35, 0x8b, 0x2f, 0xf5, 0x9f, 0x14, 0x58, 0x3a, 0xc0, 0x2e,
0x66, 0x38, 0x5f, 0x09, 0xad, 0x43, 0x15, 0x5f, 0x12, 0x76, 0x4a, 0x99, 0xcd, 0x22, 0x2a, 0x38,
0xae, 0x59, 0xc0, 0xb7, 0x4e, 0xc4, 0x0e, 0xda, 0x85, 0x0a, 0x97, 0xb0, 0x73, 0x6a, 0x33, 0xc1,
0x74, 0xb5, 0x55, 0x37, 0xe2, 0xec, 0x34, 0x92, 0xec, 0x34, 0x5e, 0x26, 0xd9, 0xb9, 0x57, 0xbe,
0x7a, 0xb3, 0x7e, 0xe7, 0xe7, 0xbf, 0xd7, 0x15, 0xab, 0x1c, 0xc3, 0x76, 0x99, 0xde, 0x84, 0xd5,
0xd8, 0x8f, 0x76, 0xe8, 0x77, 0x30, 0xa5, 0x49, 0xc8, 0x27, 0x5d, 0xfe, 0x45, 0x01, 0x74, 0x78,
0x89, 0x3b, 0x63, 0x8a, 0xd9, 0x00, 0x29, 0x79, 0x01, 0x2a, 0xdc, 0x1e, 0xa0, 0x62, 0x4e, 0x80,
0x4a, 0x23, 0x01, 0x6a, 0x42, 0x89, 0x06, 0xb8, 0x23, 0xc2, 0x5f, 0x6d, 0xad, 0x4e, 0x3c, 0x70,
0xd7, 0x1b, 0x5a, 0x42, 0x43, 0xff, 0x08, 0xee, 0x8e, 0x78, 0x98, 0x4b, 0xbf, 0x05, 0xcb, 0x16,
0xa6, 0xe4, 0x07, 0xdc, 0x66, 0xc3, 0xdc, 0x17, 0x73, 0xf7, 0xbf, 0x27, 0x0e, 0xeb, 0x49, 0xe6,
0x63, 0x81, 0xbb, 0xd9, 0xc3, 0xa4, 0xdb, 0x8b, 0xdd, 0xaf, 0x59, 0x52, 0xd2, 0x7f, 0x2d, 0x40,
0x8d, 0xc7, 0x25, 0x8d, 0xe8, 0xbc, 0x65, 0x23, 0x3d, 0x28, 0xa6, 0x1e, 0x6c, 0x71, 0x4a, 0x44,
0xf0, 0x39, 0x25, 0x4b, 0xad, 0x07, 0xd9, 0x72, 0x19, 0x6c, 0xca, 0x8a, 0x89, 0xb3, 0xc1, 0x92,
0xaa, 0x68, 0x07, 0x2a, 0x41, 0xcc, 0x00, 0xa6, 0xda, 0x82, 0x28, 0xb3, 0x0f, 0x6f, 0xc5, 0x25,
0x3c, 0xa5, 0xea, 0xff, 0x53, 0x49, 0x65, 0x73, 0xa2, 0x32, 0x9a, 0x13, 0xfa, 0x11, 0x54, 0xbf,
0x20, 0xae, 0x9b, 0xb6, 0x16, 0x95, 0x92, 0x6e, 0x92, 0x3c, 0x35, 0x4b, 0x4a, 0x9c, 0x0b, 0xdb,
0x75, 0x05, 0x41, 0x65, 0x8b, 0x2f, 0x27, 0xd9, 0xd1, 0xb7, 0x61, 0x69, 0xdf, 0xf5, 0x29, 0x3e,
0x7a, 0xf1, 0x9f, 0x31, 0x4c, 0x53, 0xb0, 0x2c, 0x1f, 0xa4, 0x7f, 0x0c, 0xef, 0x7f, 0x49, 0x28,
0x6b, 0x13, 0x87, 0x4e, 0xe9, 0x71, 0xfa, 0x43, 0x58, 0x4e, 0x55, 0x65, 0x60, 0x11, 0x94, 0x02,
0xe2, 0x50, 0x4d, 0xd9, 0x28, 0x36, 0x6b, 0x96, 0x58, 0xeb, 0x7f, 0x28, 0x70, 0x2f, 0x6d, 0x04,
0xd9, 0xee, 0xc9, 0xb5, 0x6d, 0xd6, 0x8b, 0x6d, 0x5b, 0x62, 0x8d, 0xbe, 0x83, 0x45, 0x3f, 0x60,
0xc4, 0xf7, 0x78, 0x59, 0xf3, 0x08, 0x1d, 0x18, 0xd3, 0xa6, 0x98, 0x71, 0xab, 0x75, 0xe3, 0x45,
0x6c, 0xe6, 0xd0, 0x63, 0xe1, 0xd0, 0x4a, 0x8c, 0xd6, 0x77, 0xe0, 0xbd, 0xec, 0x01, 0x27, 0xe6,
0x02, 0x0f, 0xa5, 0x0b, 0x7c, 0xc9, 0x89, 0x19, 0xd8, 0x6e, 0x94, 0xe4, 0x60, 0x2c, 0xec, 0x14,
0xb6, 0x15, 0xfd, 0x31, 0x2c, 0x9f, 0xf4, 0x48, 0xff, 0xc8, 0x3b, 0xf7, 0x6f, 0x5e, 0x7c, 0x1f,
0xca, 0xdc, 0x8d, 0xd3, 0x94, 0xdd, 0x45, 0x2e, 0xb7, 0x89, 0xa3, 0xdf, 0x83, 0xbb, 0x27, 0x2c,
0xc4, 0x76, 0xff, 0x50, 0xcc, 0x14, 0xe9, 0x97, 0xfe, 0x39, 0xac, 0xbc, 0x0a, 0x9c, 0xb1, 0x41,
0xd2, 0x82, 0x4a, 0x88, 0xa9, 0x1f, 0x85, 0x1d, 0x4c, 0x85, 0x9d, 0xbc, 0x7a, 0x4e, 0xd5, 0x5a,
0xbf, 0x55, 0xa1, 0xc4, 0xfd, 0x41, 0x6d, 0x58, 0x10, 0xf5, 0x85, 0xd6, 0x26, 0x20, 0x87, 0x7c,
0x68, 0xd7, 0xcd, 0xe9, 0x1c, 0x8e, 0x16, 0x28, 0x05, 0x35, 0xee, 0xd6, 0x68, 0x6b, 0x06, 0xfa,
0xc7, 0xc7, 0x62, 0xfd, 0x93, 0xf9, 0x40, 0xf2, 0xd2, 0xe7, 0xe2, 0x19, 0x21, 0xcb, 0x7d, 0x46,
0xce, 0x3e, 0xb2, 0x40, 0x8d, 0x5b, 0x75, 0x2e, 0xf2, 0xc9, 0x74, 0x87, 0xc6, 0x86, 0xce, 0x10,
0x6a, 0x23, 0xed, 0x1f, 0x3d, 0x9b, 0xd5, 0xc4, 0xe8, 0x18, 0x78, 0x87, 0xab, 0x5f, 0x43, 0x39,
0x29, 0x2c, 0xb4, 0x39, 0x1d, 0x3d, 0x56, 0xaf, 0xf5, 0xd6, 0x3c, 0x90, 0x94, 0xfa, 0xb6, 0x1d,
0x51, 0x3c, 0x37, 0xf5, 0xdb, 0xa0, 0x5a, 0x98, 0x46, 0xfd, 0xf9, 0x91, 0xdf, 0x02, 0xa4, 0x75,
0x8b, 0x9e, 0xbf, 0x63, 0x95, 0xe7, 0x9a, 0xf7, 0x40, 0x8d, 0x8b, 0x0f, 0x3d, 0x9d, 0x25, 0xf9,
0x27, 0xca, 0xb4, 0xfe, 0x28, 0x0b, 0x4b, 0x3e, 0x0f, 0x8d, 0xf8, 0xf3, 0x90, 0x63, 0xac, 0xd8,
0x92, 0x00, 0x3d, 0x51, 0xd0, 0x31, 0x94, 0x78, 0xf7, 0x46, 0x8f, 0xa7, 0xdf, 0x96, 0xe9, 0xf2,
0xb9, 0xee, 0x53, 0x28, 0xf1, 0x81, 0x8d, 0x66, 0xa8, 0xa4, 0xc9, 0x4f, 0x8f, 0xfa, 0xd3, 0x39,
0x51, 0x32, 0x0b, 0xbe, 0x86, 0xca, 0xcd, 0xf0, 0x47, 0x33, 0xa4, 0xd1, 0xf8, 0x97, 0x42, 0xee,
0x6b, 0x4e, 0x60, 0x51, 0xce, 0x23, 0x34, 0x43, 0x39, 0x8c, 0x8e, 0xae, 0x5c, 0xa3, 0x5f, 0x41,
0x39, 0xe9, 0xc6, 0xb9, 0xc9, 0x37, 0xc3, 0x23, 0x26, 0x3a, 0xfa, 0x2b, 0x50, 0xe3, 0xfe, 0x3c,
0x4b, 0xef, 0x9b, 0xe8, 0xe4, 0x79, 0xee, 0xee, 0x1d, 0x5f, 0xbd, 0x6d, 0xdc, 0xf9, 0xeb, 0x6d,
0xe3, 0xce, 0x8f, 0xd7, 0x0d, 0xe5, 0xea, 0xba, 0xa1, 0xfc, 0x79, 0xdd, 0x50, 0xfe, 0xb9, 0x6e,
0x28, 0xdf, 0x6c, 0xcd, 0xf7, 0x1f, 0xde, 0x67, 0xfc, 0xf7, 0x4c, 0x15, 0xe6, 0xb7, 0xfe, 0x0d,
0x00, 0x00, 0xff, 0xff, 0xf6, 0xcc, 0xc3, 0x0f, 0x1f, 0x0e, 0x00, 0x00,
// 1114 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0x4f, 0x6f, 0xe3, 0x44,
0x14, 0xaf, 0x93, 0xd4, 0x4d, 0x5e, 0x94, 0xd2, 0xce, 0x76, 0x8b, 0x37, 0x8b, 0xd2, 0xc8, 0x87,
0x25, 0x68, 0xb5, 0xf6, 0x36, 0x65, 0xff, 0xb0, 0x9c, 0xda, 0x6e, 0x85, 0x2a, 0xa8, 0x88, 0xdc,
0x5d, 0x90, 0x40, 0xa8, 0x72, 0xe3, 0x69, 0x32, 0x6a, 0xe2, 0xf1, 0x7a, 0xc6, 0xa5, 0xe5, 0xc4,
0x89, 0x33, 0x1f, 0x81, 0x03, 0x37, 0xbe, 0x48, 0x8f, 0x1c, 0x39, 0x2d, 0x6c, 0xee, 0x7c, 0x07,
0x34, 0xe3, 0x71, 0xed, 0x24, 0x35, 0x49, 0x10, 0x97, 0x66, 0xde, 0xcc, 0xfb, 0xcd, 0xfc, 0xde,
0x7f, 0x17, 0x3e, 0xe9, 0x11, 0xde, 0x8f, 0x4e, 0xad, 0x2e, 0x1d, 0xda, 0x5d, 0xea, 0x73, 0x97,
0xf8, 0x38, 0xf4, 0xb2, 0xcb, 0x01, 0xf1, 0xa3, 0x4b, 0x9b, 0xf5, 0xc9, 0xd0, 0xbe, 0xd8, 0x96,
0xbf, 0x56, 0x10, 0x52, 0x4e, 0x51, 0x33, 0x55, 0xb2, 0xc2, 0xc8, 0xe7, 0x64, 0x88, 0x2d, 0xa9,
0x6c, 0x49, 0xa5, 0x8b, 0xed, 0xfa, 0xbd, 0x1e, 0xa5, 0xbd, 0x01, 0xb6, 0xa5, 0xfe, 0x69, 0x74,
0x66, 0xbb, 0xfe, 0x55, 0x0c, 0xae, 0xdf, 0x9f, 0x3c, 0xc2, 0xc3, 0x80, 0x27, 0x87, 0x1b, 0x3d,
0xda, 0xa3, 0x72, 0x69, 0x8b, 0x95, 0xda, 0xdd, 0x9a, 0x84, 0x88, 0x17, 0x19, 0x77, 0x87, 0x81,
0x52, 0x78, 0x3a, 0xd3, 0x16, 0x37, 0x20, 0x36, 0xbf, 0x0a, 0x30, 0xb3, 0x87, 0x34, 0xf2, 0xb9,
0xc2, 0xbd, 0x58, 0x00, 0xc7, 0x5d, 0x76, 0x2e, 0xff, 0x28, 0xec, 0xc1, 0x5c, 0x58, 0x86, 0xc3,
0x0b, 0xd2, 0xc5, 0xcc, 0xc6, 0x17, 0xd8, 0xe7, 0x4c, 0x38, 0x32, 0xf1, 0x98, 0xbc, 0xc6, 0xfc,
0xbb, 0x00, 0xeb, 0xfb, 0x21, 0x76, 0x39, 0x7e, 0xe5, 0xb2, 0x73, 0x07, 0xbf, 0x89, 0x30, 0xe3,
0x68, 0x13, 0x0a, 0xc4, 0x33, 0xb4, 0xa6, 0xd6, 0xaa, 0xec, 0xe9, 0xa3, 0xb7, 0x5b, 0x85, 0xc3,
0x97, 0x4e, 0x81, 0x78, 0x68, 0x13, 0xf4, 0xd3, 0xc8, 0xf7, 0x06, 0xd8, 0x28, 0x88, 0x33, 0x47,
0x49, 0xc8, 0x80, 0x15, 0x75, 0xad, 0x51, 0x94, 0x07, 0x89, 0x88, 0x6c, 0xd0, 0x43, 0x4a, 0xf9,
0x19, 0x33, 0x4a, 0xcd, 0x62, 0xab, 0xda, 0x7e, 0xdf, 0xca, 0x04, 0x4f, 0x5a, 0x66, 0x1d, 0x09,
0x8f, 0x38, 0x4a, 0x0d, 0xd5, 0xa1, 0xcc, 0x71, 0x38, 0x24, 0xbe, 0x3b, 0x30, 0x96, 0x9b, 0x5a,
0xab, 0xec, 0xdc, 0xc8, 0x68, 0x03, 0x96, 0x19, 0xf7, 0x88, 0x6f, 0xe8, 0xf2, 0x91, 0x58, 0x10,
0xa4, 0x18, 0xf7, 0x68, 0xc4, 0x8d, 0x95, 0x98, 0x54, 0x2c, 0xa9, 0x7d, 0x1c, 0x86, 0x46, 0xf9,
0x66, 0x1f, 0x87, 0x21, 0x6a, 0x00, 0x74, 0xfb, 0xb8, 0x7b, 0x1e, 0x50, 0xe2, 0x73, 0xa3, 0x22,
0xcf, 0x32, 0x3b, 0xe8, 0x21, 0xac, 0x07, 0x6e, 0x88, 0x7d, 0x7e, 0x92, 0x51, 0x03, 0xa9, 0xb6,
0x16, 0x1f, 0xec, 0xa7, 0xca, 0x16, 0xac, 0xd0, 0x80, 0x13, 0xea, 0x33, 0xa3, 0xda, 0xd4, 0x5a,
0xd5, 0xf6, 0x86, 0x15, 0x67, 0x8b, 0x95, 0x64, 0x8b, 0xb5, 0xeb, 0x5f, 0x39, 0x89, 0x92, 0xf9,
0x00, 0x50, 0xd6, 0xdd, 0x2c, 0xa0, 0x3e, 0xc3, 0x68, 0x0d, 0x8a, 0x81, 0x72, 0x78, 0xcd, 0x11,
0x4b, 0xf3, 0x27, 0x0d, 0x56, 0x5f, 0xe2, 0x01, 0xe6, 0x38, 0x5f, 0x09, 0x6d, 0x41, 0x15, 0x5f,
0x12, 0x7e, 0xc2, 0xb8, 0xcb, 0x23, 0x26, 0x63, 0x52, 0x73, 0x40, 0x6c, 0x1d, 0xcb, 0x1d, 0xb4,
0x0b, 0x15, 0x21, 0x61, 0xef, 0xc4, 0xe5, 0x32, 0x32, 0xd5, 0x76, 0x7d, 0x8a, 0xdf, 0xab, 0x24,
0x9b, 0xf7, 0xca, 0xd7, 0x6f, 0xb7, 0x96, 0x7e, 0xfe, 0x73, 0x4b, 0x73, 0xca, 0x31, 0x6c, 0x97,
0x9b, 0x2d, 0xd8, 0x88, 0x79, 0x74, 0x42, 0xda, 0xc5, 0x8c, 0x25, 0x29, 0x32, 0x4d, 0xf9, 0x17,
0x0d, 0xd0, 0xc1, 0x25, 0xee, 0x4e, 0x28, 0x66, 0x03, 0xaa, 0xe5, 0x05, 0xb4, 0x70, 0x7b, 0x40,
0x8b, 0x39, 0x01, 0x2d, 0x8d, 0x05, 0xb4, 0x05, 0x25, 0x16, 0xe0, 0xae, 0x4c, 0x97, 0xbc, 0x00,
0x48, 0x0d, 0xf3, 0x43, 0xb8, 0x33, 0xc6, 0x30, 0xd7, 0xfd, 0x0e, 0xac, 0x39, 0x98, 0x91, 0x1f,
0x70, 0x87, 0x5f, 0xe5, 0x5a, 0x2c, 0xe8, 0x7f, 0x4f, 0x3c, 0xde, 0x57, 0x9e, 0x8f, 0x05, 0x41,
0xb3, 0x8f, 0x49, 0xaf, 0x1f, 0xd3, 0xaf, 0x39, 0x4a, 0x32, 0x7f, 0x2d, 0x40, 0x4d, 0xc4, 0x25,
0x8d, 0xe8, 0xa2, 0x65, 0xa6, 0x18, 0x14, 0x53, 0x06, 0x3b, 0xc2, 0x25, 0x32, 0xf8, 0xc2, 0x25,
0xab, 0xed, 0xfb, 0xd9, 0xf2, 0xba, 0xd8, 0x56, 0x15, 0x16, 0x67, 0x83, 0xa3, 0x54, 0xd1, 0x0b,
0xa8, 0x04, 0xb1, 0x07, 0x30, 0x33, 0x96, 0x65, 0x59, 0x7e, 0x70, 0x2b, 0x2e, 0xf1, 0x53, 0xaa,
0xfe, 0x3f, 0x95, 0x60, 0x36, 0x27, 0x2a, 0xe3, 0x39, 0x61, 0x1e, 0x42, 0xf5, 0x73, 0x32, 0x18,
0xa4, 0xad, 0x48, 0x67, 0xa4, 0x97, 0x24, 0x4f, 0xcd, 0x51, 0x92, 0xf0, 0x85, 0x3b, 0x18, 0x48,
0x07, 0x95, 0x1d, 0xb1, 0x9c, 0xf6, 0x8e, 0xf9, 0x1c, 0x56, 0xf7, 0x07, 0x94, 0xe1, 0xc3, 0x2f,
0xff, 0x35, 0x86, 0x69, 0x0a, 0x96, 0x95, 0x41, 0xe6, 0x47, 0xf0, 0xde, 0x17, 0x84, 0xf1, 0x0e,
0xf1, 0xd8, 0x8c, 0x9e, 0x68, 0x3e, 0x80, 0xb5, 0x54, 0x55, 0x05, 0x16, 0x41, 0x29, 0x20, 0x1e,
0x33, 0xb4, 0x66, 0xb1, 0x55, 0x73, 0xe4, 0xda, 0xfc, 0x16, 0xee, 0xa6, 0x7d, 0x23, 0xdb, 0x6c,
0x85, 0xb2, 0xcb, 0xfb, 0xf1, 0xd5, 0x8e, 0x5c, 0x67, 0xdb, 0x4a, 0x61, 0x9e, 0xb6, 0xf2, 0x08,
0xd6, 0x8e, 0xfb, 0x64, 0x78, 0xe8, 0x9f, 0xd1, 0x1b, 0x12, 0xf7, 0xa0, 0x2c, 0xe6, 0xe1, 0x49,
0x6a, 0xf0, 0x8a, 0x90, 0x3b, 0xc4, 0x33, 0xef, 0xc2, 0x9d, 0x63, 0x1e, 0x62, 0x77, 0x78, 0x20,
0xc7, 0x82, 0x62, 0x62, 0x7e, 0x06, 0xeb, 0xaf, 0x03, 0x6f, 0x62, 0x16, 0xb4, 0xa1, 0x12, 0x62,
0x46, 0xa3, 0xb0, 0x8b, 0x99, 0xbc, 0x27, 0x8f, 0x4c, 0xaa, 0xd6, 0xfe, 0xad, 0x0a, 0x25, 0xc1,
0x07, 0x75, 0x60, 0x59, 0xa6, 0x3c, 0xda, 0x9c, 0x82, 0x1c, 0x88, 0xb9, 0x5b, 0xb7, 0xad, 0x59,
0xc3, 0xdc, 0x1a, 0xaf, 0x19, 0x06, 0x7a, 0xdc, 0x40, 0xd1, 0xce, 0x6c, 0xe8, 0xd4, 0x64, 0xab,
0x7f, 0xbc, 0x18, 0x48, 0x3d, 0xfa, 0x4c, 0x9a, 0x11, 0xf2, 0x5c, 0x33, 0x72, 0xf6, 0x91, 0x03,
0x7a, 0xdc, 0x3d, 0x73, 0x91, 0x8f, 0x67, 0x13, 0x9a, 0x98, 0x03, 0x57, 0x50, 0x1b, 0xeb, 0xc8,
0xe8, 0xe9, 0xbc, 0x57, 0x8c, 0x77, 0xe6, 0xff, 0xf0, 0xf4, 0x1b, 0x28, 0x27, 0xb9, 0x8e, 0xb6,
0x67, 0xa3, 0x27, 0x4a, 0xa8, 0xde, 0x5e, 0x04, 0x92, 0xba, 0xbe, 0xe3, 0x46, 0x0c, 0x2f, 0xec,
0xfa, 0xe7, 0xa0, 0x3b, 0x98, 0x45, 0xc3, 0xc5, 0x91, 0xdf, 0x01, 0x64, 0x26, 0xfc, 0xb3, 0x39,
0x32, 0xe6, 0xb6, 0xba, 0xce, 0xbd, 0xde, 0x07, 0x3d, 0x2e, 0x3e, 0xf4, 0x64, 0x9e, 0xe4, 0x9f,
0x2a, 0xd3, 0xfa, 0xc3, 0x2c, 0x2c, 0xf9, 0xc2, 0xb3, 0xe2, 0x2f, 0x3c, 0x81, 0x71, 0xe2, 0x9b,
0x24, 0xe8, 0xb1, 0x86, 0x8e, 0xa0, 0x24, 0x1a, 0x2a, 0x7a, 0x34, 0xfb, 0xb5, 0x4c, 0xe3, 0xcd,
0xa5, 0xcf, 0xa0, 0x24, 0x66, 0x28, 0x9a, 0xa3, 0x92, 0xa6, 0xbf, 0x06, 0xea, 0x4f, 0x16, 0x44,
0xa9, 0x2c, 0xf8, 0x1a, 0x2a, 0x37, 0xf3, 0x18, 0xcd, 0x91, 0x46, 0x93, 0xc3, 0x3b, 0xd7, 0x9a,
0x63, 0x58, 0x51, 0x23, 0x02, 0xcd, 0x51, 0x0e, 0xe3, 0xd3, 0x24, 0xf7, 0xd2, 0xaf, 0xa0, 0x9c,
0x74, 0xe3, 0xdc, 0xe4, 0x9b, 0xc3, 0x88, 0xa9, 0x8e, 0xfe, 0x1a, 0xf4, 0xb8, 0x3f, 0xcf, 0xd3,
0xfb, 0xa6, 0x3a, 0x79, 0x1e, 0xdd, 0xbd, 0xa3, 0xeb, 0x77, 0x8d, 0xa5, 0x3f, 0xde, 0x35, 0x96,
0x7e, 0x1c, 0x35, 0xb4, 0xeb, 0x51, 0x43, 0xfb, 0x7d, 0xd4, 0xd0, 0xfe, 0x1a, 0x35, 0xb4, 0x6f,
0x76, 0x16, 0xfb, 0x27, 0xed, 0x53, 0xf1, 0x7b, 0xaa, 0xcb, 0xeb, 0x77, 0xfe, 0x09, 0x00, 0x00,
0xff, 0xff, 0xe2, 0x51, 0xa8, 0x39, 0xe2, 0x0d, 0x00, 0x00,
}

3
linux/shim/v1/shim.proto
View File

@@ -63,6 +63,7 @@ message CreateTaskRequest {
string stderr = 8;
string checkpoint = 9;
string parent_checkpoint = 10;
google.protobuf.Any options = 11;
}
message CreateTaskResponse {
@@ -130,7 +131,7 @@ message ListPidsResponse{
message CheckpointTaskRequest {
string path = 1;
map<string, string> options = 2;
google.protobuf.Any options = 2;
}
message ShimInfoResponse {

8
linux/task.go
View File

@@ -160,10 +160,12 @@ func (t *Task) CloseIO(ctx context.Context, pid uint32) error {
return err
}
func (t *Task) Checkpoint(ctx context.Context, path string, options map[string]string) error {
func (t *Task) Checkpoint(ctx context.Context, path string, options []byte) error {
r := &shim.CheckpointTaskRequest{
Path: path,
Options: options,
Path: path,
Options: &protobuf.Any{
Value: options,
},
}
if _, err := t.shim.Checkpoint(ctx, r); err != nil {
return errors.New(grpc.ErrorDesc(err))