Add create/start to exec processes in shim

This splits up the create and start of an exec process in the shim to
have two separate steps like the initial process.  This will allow
better state reporting for individual process along with a more robust
wait for execs.

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

linux/shim/exec.go

@@ -36,6 +36,8 @@ type execProcess struct {
 	closers []io.Closer
 	stdin   io.Closer
 	stdio   stdio
+	path    string
+	spec    specs.Process
 
 	parent *initProcess
 }
@@ -44,43 +46,6 @@ func newExecProcess(context context.Context, path string, r *shimapi.ExecProcess
 	if err := identifiers.Validate(id); err != nil {
 		return nil, errors.Wrapf(err, "invalid exec id")
 	}
-
-	e := &execProcess{
-		id:     id,
-		parent: parent,
-		stdio: stdio{
-			stdin:    r.Stdin,
-			stdout:   r.Stdout,
-			stderr:   r.Stderr,
-			terminal: r.Terminal,
-		},
-	}
-	var (
-		err     error
-		socket  *runc.Socket
-		io      runc.IO
-		pidfile = filepath.Join(path, fmt.Sprintf("%s.pid", id))
-	)
-	if r.Terminal {
-		if socket, err = runc.NewConsoleSocket(filepath.Join(path, "pty.sock")); err != nil {
-			return nil, errors.Wrap(err, "failed to create runc console socket")
-		}
-		defer os.Remove(socket.Path())
-	} else {
-		// TODO: get uid/gid
-		if io, err = runc.NewPipeIO(0, 0); err != nil {
-			return nil, errors.Wrap(err, "failed to create runc io pipes")
-		}
-		e.io = io
-	}
-	opts := &runc.ExecOpts{
-		PidFile: pidfile,
-		IO:      io,
-		Detach:  true,
-	}
-	if socket != nil {
-		opts.ConsoleSocket = socket
-	}
 	// process exec request
 	var spec specs.Process
 	if err := json.Unmarshal(r.Spec.Value, &spec); err != nil {
@@ -88,39 +53,18 @@ func newExecProcess(context context.Context, path string, r *shimapi.ExecProcess
 	}
 	spec.Terminal = r.Terminal
 
-	if err := parent.runtime.Exec(context, parent.id, spec, opts); err != nil {
-		return nil, parent.runtimeError(err, "OCI runtime exec failed")
+	e := &execProcess{
+		id:     id,
+		path:   path,
+		parent: parent,
+		spec:   spec,
+		stdio: stdio{
+			stdin:    r.Stdin,
+			stdout:   r.Stdout,
+			stderr:   r.Stderr,
+			terminal: r.Terminal,
+		},
 	}
-	if r.Stdin != "" {
-		sc, err := fifo.OpenFifo(context, r.Stdin, syscall.O_WRONLY|syscall.O_NONBLOCK, 0)
-		if err != nil {
-			return nil, errors.Wrapf(err, "failed to open stdin fifo %s", r.Stdin)
-		}
-		e.closers = append(e.closers, sc)
-		e.stdin = sc
-	}
-	var copyWaitGroup sync.WaitGroup
-	if socket != nil {
-		console, err := socket.ReceiveMaster()
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to retrieve console master")
-		}
-		console, err = e.parent.platform.copyConsole(context, console, r.Stdin, r.Stdout, r.Stderr, &e.WaitGroup, &copyWaitGroup)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to start console copy")
-		}
-		e.console = console
-	} else {
-		if err := copyPipes(context, io, r.Stdin, r.Stdout, r.Stderr, &e.WaitGroup, &copyWaitGroup); err != nil {
-			return nil, errors.Wrap(err, "failed to start io pipe copy")
-		}
-	}
-	copyWaitGroup.Wait()
-	pid, err := runc.ReadPidFile(opts.PidFile)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to retrieve OCI runtime exec pid")
-	}
-	e.pid = pid
 	return e, nil
 }
 
@@ -178,3 +122,63 @@ func (e *execProcess) Stdin() io.Closer {
 func (e *execProcess) Stdio() stdio {
 	return e.stdio
 }
+
+func (e *execProcess) Start(ctx context.Context) (err error) {
+	var (
+		socket  *runc.Socket
+		io      runc.IO
+		pidfile = filepath.Join(e.path, fmt.Sprintf("%s.pid", e.id))
+	)
+	if e.stdio.terminal {
+		if socket, err = runc.NewConsoleSocket(filepath.Join(e.path, "pty.sock")); err != nil {
+			return errors.Wrap(err, "failed to create runc console socket")
+		}
+		defer os.Remove(socket.Path())
+	} else {
+		if io, err = runc.NewPipeIO(0, 0); err != nil {
+			return errors.Wrap(err, "failed to create runc io pipes")
+		}
+		e.io = io
+	}
+	opts := &runc.ExecOpts{
+		PidFile: pidfile,
+		IO:      io,
+		Detach:  true,
+	}
+	if socket != nil {
+		opts.ConsoleSocket = socket
+	}
+	if err := e.parent.runtime.Exec(ctx, e.parent.id, e.spec, opts); err != nil {
+		return e.parent.runtimeError(err, "OCI runtime exec failed")
+	}
+	if e.stdio.stdin != "" {
+		sc, err := fifo.OpenFifo(ctx, e.stdio.stdin, syscall.O_WRONLY|syscall.O_NONBLOCK, 0)
+		if err != nil {
+			return errors.Wrapf(err, "failed to open stdin fifo %s", e.stdio.stdin)
+		}
+		e.closers = append(e.closers, sc)
+		e.stdin = sc
+	}
+	var copyWaitGroup sync.WaitGroup
+	if socket != nil {
+		console, err := socket.ReceiveMaster()
+		if err != nil {
+			return errors.Wrap(err, "failed to retrieve console master")
+		}
+		e.console = console
+		if err := e.parent.platform.copyConsole(ctx, console, e.stdio.stdin, e.stdio.stdout, e.stdio.stderr, &e.WaitGroup, &copyWaitGroup); err != nil {
+			return errors.Wrap(err, "failed to start console copy")
+		}
+	} else {
+		if err := copyPipes(ctx, io, e.stdio.stdin, e.stdio.stdout, e.stdio.stderr, &e.WaitGroup, &copyWaitGroup); err != nil {
+			return errors.Wrap(err, "failed to start io pipe copy")
+		}
+	}
+	copyWaitGroup.Wait()
+	pid, err := runc.ReadPidFile(opts.PidFile)
+	if err != nil {
+		return errors.Wrap(err, "failed to retrieve OCI runtime exec pid")
+	}
+	e.pid = pid
+	return nil
+}

linux/shim/local.go

@@ -27,7 +27,7 @@ func (c *local) Create(ctx context.Context, in *shimapi.CreateTaskRequest, opts
 	return c.s.Create(ctx, in)
 }
 
-func (c *local) Start(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+func (c *local) Start(ctx context.Context, in *shimapi.StartRequest, opts ...grpc.CallOption) (*shimapi.StartResponse, error) {
 	return c.s.Start(ctx, in)
 }
 
@@ -43,7 +43,7 @@ func (c *local) DeleteProcess(ctx context.Context, in *shimapi.DeleteProcessRequ
 	return c.s.DeleteProcess(ctx, in)
 }
 
-func (c *local) Exec(ctx context.Context, in *shimapi.ExecProcessRequest, opts ...grpc.CallOption) (*shimapi.ExecProcessResponse, error) {
+func (c *local) Exec(ctx context.Context, in *shimapi.ExecProcessRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
 	return c.s.Exec(ctx, in)
 }
 

linux/shim/process.go

@@ -38,4 +38,6 @@ type process interface {
 	Kill(context.Context, uint32, bool) error
 	// Stdio returns io information for the container
 	Stdio() stdio
+	// Start execution of the process
+	Start(context.Context) error
 }

linux/shim/service.go

@@ -108,18 +108,36 @@ func (s *Service) Create(ctx context.Context, r *shimapi.CreateTaskRequest) (*sh
 	}, nil
 }
 
-func (s *Service) Start(ctx context.Context, r *google_protobuf.Empty) (*google_protobuf.Empty, error) {
-	if s.initProcess == nil {
-		return nil, errdefs.ToGRPCf(errdefs.ErrFailedPrecondition, "container must be created")
+func (s *Service) Start(ctx context.Context, r *shimapi.StartRequest) (*shimapi.StartResponse, error) {
+	p, ok := s.processes[r.ID]
+	if !ok {
+		return nil, errdefs.ToGRPCf(errdefs.ErrNotFound, "process %s not found", r.ID)
 	}
-	if err := s.initProcess.Start(ctx); err != nil {
+	if err := p.Start(ctx); err != nil {
 		return nil, err
 	}
-	s.events <- &eventsapi.TaskStart{
-		ContainerID: s.id,
-		Pid:         uint32(s.initProcess.Pid()),
+	if r.ID == s.id {
+		s.events <- &eventsapi.TaskStart{
+			ContainerID: s.id,
+			Pid:         uint32(s.initProcess.Pid()),
+		}
+	} else {
+		pid := p.Pid()
+		cmd := &reaper.Cmd{
+			ExitCh: make(chan int, 1),
+		}
+		reaper.Default.Register(pid, cmd)
+		go s.waitExit(p, pid, cmd)
+		s.events <- &eventsapi.TaskExecStarted{
+			ContainerID: s.id,
+			ExecID:      r.ID,
+			Pid:         uint32(pid),
+		}
 	}
-	return empty, nil
+	return &shimapi.StartResponse{
+		ID:  p.ID(),
+		Pid: uint32(p.Pid()),
+	}, nil
 }
 
 func (s *Service) Delete(ctx context.Context, r *google_protobuf.Empty) (*shimapi.DeleteResponse, error) {
@@ -170,7 +188,7 @@ func (s *Service) DeleteProcess(ctx context.Context, r *shimapi.DeleteProcessReq
 	}, nil
 }
 
-func (s *Service) Exec(ctx context.Context, r *shimapi.ExecProcessRequest) (*shimapi.ExecProcessResponse, error) {
+func (s *Service) Exec(ctx context.Context, r *shimapi.ExecProcessRequest) (*google_protobuf.Empty, error) {
 	if s.initProcess == nil {
 		return nil, errdefs.ToGRPCf(errdefs.ErrFailedPrecondition, "container must be created")
 	}
@@ -181,22 +199,13 @@ func (s *Service) Exec(ctx context.Context, r *shimapi.ExecProcessRequest) (*shi
 	if err != nil {
 		return nil, errdefs.ToGRPC(err)
 	}
-	pid := process.Pid()
-	cmd := &reaper.Cmd{
-		ExitCh: make(chan int, 1),
-	}
-	reaper.Default.Register(pid, cmd)
 	s.processes[r.ID] = process
 
 	s.events <- &eventsapi.TaskExecAdded{
 		ContainerID: s.id,
 		ExecID:      r.ID,
-		Pid:         uint32(pid),
 	}
-	go s.waitExit(process, pid, cmd)
-	return &shimapi.ExecProcessResponse{
-		Pid: uint32(pid),
-	}, nil
+	return empty, nil
 }
 
 func (s *Service) ResizePty(ctx context.Context, r *shimapi.ResizePtyRequest) (*google_protobuf.Empty, error) {

linux/shim/v1/shim.pb.go

@@ -25,6 +25,8 @@
 		CheckpointTaskRequest
 		ShimInfoResponse
 		UpdateTaskRequest
+		StartRequest
+		StartResponse
 */
 package shim
 
@@ -122,7 +124,6 @@ func (*ExecProcessRequest) ProtoMessage()               {}
 func (*ExecProcessRequest) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{4} }
 
 type ExecProcessResponse struct {
-	Pid uint32 `protobuf:"varint,1,opt,name=pid,proto3" json:"pid,omitempty"`
 }
 
 func (m *ExecProcessResponse) Reset()                    { *m = ExecProcessResponse{} }
@@ -222,6 +223,23 @@ func (m *UpdateTaskRequest) Reset()                    { *m = UpdateTaskRequest{
 func (*UpdateTaskRequest) ProtoMessage()               {}
 func (*UpdateTaskRequest) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{15} }
 
+type StartRequest struct {
+	ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+}
+
+func (m *StartRequest) Reset()                    { *m = StartRequest{} }
+func (*StartRequest) ProtoMessage()               {}
+func (*StartRequest) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{16} }
+
+type StartResponse struct {
+	ID  string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+	Pid uint32 `protobuf:"varint,2,opt,name=pid,proto3" json:"pid,omitempty"`
+}
+
+func (m *StartResponse) Reset()                    { *m = StartResponse{} }
+func (*StartResponse) ProtoMessage()               {}
+func (*StartResponse) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{17} }
+
 func init() {
 	proto.RegisterType((*CreateTaskRequest)(nil), "containerd.runtime.linux.shim.v1.CreateTaskRequest")
 	proto.RegisterType((*CreateTaskResponse)(nil), "containerd.runtime.linux.shim.v1.CreateTaskResponse")
@@ -239,6 +257,8 @@ func init() {
 	proto.RegisterType((*CheckpointTaskRequest)(nil), "containerd.runtime.linux.shim.v1.CheckpointTaskRequest")
 	proto.RegisterType((*ShimInfoResponse)(nil), "containerd.runtime.linux.shim.v1.ShimInfoResponse")
 	proto.RegisterType((*UpdateTaskRequest)(nil), "containerd.runtime.linux.shim.v1.UpdateTaskRequest")
+	proto.RegisterType((*StartRequest)(nil), "containerd.runtime.linux.shim.v1.StartRequest")
+	proto.RegisterType((*StartResponse)(nil), "containerd.runtime.linux.shim.v1.StartResponse")
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -255,7 +275,7 @@ type ShimClient interface {
 	// State returns shim and task state information.
 	State(ctx context.Context, in *StateRequest, opts ...grpc.CallOption) (*StateResponse, error)
 	Create(ctx context.Context, in *CreateTaskRequest, opts ...grpc.CallOption) (*CreateTaskResponse, error)
-	Start(ctx context.Context, in *google_protobuf1.Empty, opts ...grpc.CallOption) (*google_protobuf1.Empty, error)
+	Start(ctx context.Context, in *StartRequest, opts ...grpc.CallOption) (*StartResponse, error)
 	Delete(ctx context.Context, in *google_protobuf1.Empty, opts ...grpc.CallOption) (*DeleteResponse, error)
 	DeleteProcess(ctx context.Context, in *DeleteProcessRequest, opts ...grpc.CallOption) (*DeleteResponse, error)
 	ListPids(ctx context.Context, in *ListPidsRequest, opts ...grpc.CallOption) (*ListPidsResponse, error)
@@ -263,7 +283,7 @@ type ShimClient interface {
 	Resume(ctx context.Context, in *google_protobuf1.Empty, opts ...grpc.CallOption) (*google_protobuf1.Empty, error)
 	Checkpoint(ctx context.Context, in *CheckpointTaskRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error)
 	Kill(ctx context.Context, in *KillRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error)
-	Exec(ctx context.Context, in *ExecProcessRequest, opts ...grpc.CallOption) (*ExecProcessResponse, error)
+	Exec(ctx context.Context, in *ExecProcessRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error)
 	ResizePty(ctx context.Context, in *ResizePtyRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error)
 	CloseIO(ctx context.Context, in *CloseIORequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error)
 	// ShimInfo returns information about the shim.
@@ -297,8 +317,8 @@ func (c *shimClient) Create(ctx context.Context, in *CreateTaskRequest, opts ...
 	return out, nil
 }
 
-func (c *shimClient) Start(ctx context.Context, in *google_protobuf1.Empty, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) {
-	out := new(google_protobuf1.Empty)
+func (c *shimClient) Start(ctx context.Context, in *StartRequest, opts ...grpc.CallOption) (*StartResponse, error) {
+	out := new(StartResponse)
 	err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/Start", in, out, c.cc, opts...)
 	if err != nil {
 		return nil, err
@@ -369,8 +389,8 @@ func (c *shimClient) Kill(ctx context.Context, in *KillRequest, opts ...grpc.Cal
 	return out, nil
 }
 
-func (c *shimClient) Exec(ctx context.Context, in *ExecProcessRequest, opts ...grpc.CallOption) (*ExecProcessResponse, error) {
-	out := new(ExecProcessResponse)
+func (c *shimClient) Exec(ctx context.Context, in *ExecProcessRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) {
+	out := new(google_protobuf1.Empty)
 	err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/Exec", in, out, c.cc, opts...)
 	if err != nil {
 		return nil, err
@@ -420,7 +440,7 @@ type ShimServer interface {
 	// State returns shim and task state information.
 	State(context.Context, *StateRequest) (*StateResponse, error)
 	Create(context.Context, *CreateTaskRequest) (*CreateTaskResponse, error)
-	Start(context.Context, *google_protobuf1.Empty) (*google_protobuf1.Empty, error)
+	Start(context.Context, *StartRequest) (*StartResponse, error)
 	Delete(context.Context, *google_protobuf1.Empty) (*DeleteResponse, error)
 	DeleteProcess(context.Context, *DeleteProcessRequest) (*DeleteResponse, error)
 	ListPids(context.Context, *ListPidsRequest) (*ListPidsResponse, error)
@@ -428,7 +448,7 @@ type ShimServer interface {
 	Resume(context.Context, *google_protobuf1.Empty) (*google_protobuf1.Empty, error)
 	Checkpoint(context.Context, *CheckpointTaskRequest) (*google_protobuf1.Empty, error)
 	Kill(context.Context, *KillRequest) (*google_protobuf1.Empty, error)
-	Exec(context.Context, *ExecProcessRequest) (*ExecProcessResponse, error)
+	Exec(context.Context, *ExecProcessRequest) (*google_protobuf1.Empty, error)
 	ResizePty(context.Context, *ResizePtyRequest) (*google_protobuf1.Empty, error)
 	CloseIO(context.Context, *CloseIORequest) (*google_protobuf1.Empty, error)
 	// ShimInfo returns information about the shim.
@@ -477,7 +497,7 @@ func _Shim_Create_Handler(srv interface{}, ctx context.Context, dec func(interfa
 }
 
 func _Shim_Start_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(google_protobuf1.Empty)
+	in := new(StartRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
@@ -489,7 +509,7 @@ func _Shim_Start_Handler(srv interface{}, ctx context.Context, dec func(interfac
 		FullMethod: "/containerd.runtime.linux.shim.v1.Shim/Start",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ShimServer).Start(ctx, req.(*google_protobuf1.Empty))
+		return srv.(ShimServer).Start(ctx, req.(*StartRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -1037,11 +1057,6 @@ func (m *ExecProcessResponse) MarshalTo(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.Pid != 0 {
-		dAtA[i] = 0x8
-		i++
-		i = encodeVarintShim(dAtA, i, uint64(m.Pid))
-	}
 	return i, nil
 }
 
@@ -1388,6 +1403,59 @@ func (m *UpdateTaskRequest) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
+func (m *StartRequest) 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 *StartRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.ID) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintShim(dAtA, i, uint64(len(m.ID)))
+		i += copy(dAtA[i:], m.ID)
+	}
+	return i, nil
+}
+
+func (m *StartResponse) 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 *StartResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.ID) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintShim(dAtA, i, uint64(len(m.ID)))
+		i += copy(dAtA[i:], m.ID)
+	}
+	if m.Pid != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintShim(dAtA, i, uint64(m.Pid))
+	}
+	return i, nil
+}
+
 func encodeFixed64Shim(dAtA []byte, offset int, v uint64) int {
 	dAtA[offset] = uint8(v)
 	dAtA[offset+1] = uint8(v >> 8)
@@ -1531,9 +1599,6 @@ func (m *ExecProcessRequest) Size() (n int) {
 func (m *ExecProcessResponse) Size() (n int) {
 	var l int
 	_ = l
-	if m.Pid != 0 {
-		n += 1 + sovShim(uint64(m.Pid))
-	}
 	return n
 }
 
@@ -1683,6 +1748,29 @@ func (m *UpdateTaskRequest) Size() (n int) {
 	return n
 }
 
+func (m *StartRequest) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.ID)
+	if l > 0 {
+		n += 1 + l + sovShim(uint64(l))
+	}
+	return n
+}
+
+func (m *StartResponse) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.ID)
+	if l > 0 {
+		n += 1 + l + sovShim(uint64(l))
+	}
+	if m.Pid != 0 {
+		n += 1 + sovShim(uint64(m.Pid))
+	}
+	return n
+}
+
 func sovShim(x uint64) (n int) {
 	for {
 		n++
@@ -1768,7 +1856,6 @@ func (this *ExecProcessResponse) String() string {
 		return "nil"
 	}
 	s := strings.Join([]string{`&ExecProcessResponse{`,
-		`Pid:` + fmt.Sprintf("%v", this.Pid) + `,`,
 		`}`,
 	}, "")
 	return s
@@ -1886,6 +1973,27 @@ func (this *UpdateTaskRequest) String() string {
 	}, "")
 	return s
 }
+func (this *StartRequest) String() string {
+	if this == nil {
+		return "nil"
+	}
+	s := strings.Join([]string{`&StartRequest{`,
+		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
+		`}`,
+	}, "")
+	return s
+}
+func (this *StartResponse) String() string {
+	if this == nil {
+		return "nil"
+	}
+	s := strings.Join([]string{`&StartResponse{`,
+		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
+		`Pid:` + fmt.Sprintf("%v", this.Pid) + `,`,
+		`}`,
+	}, "")
+	return s
+}
 func valueToStringShim(v interface{}) string {
 	rv := reflect.ValueOf(v)
 	if rv.IsNil() {
@@ -2774,25 +2882,6 @@ func (m *ExecProcessResponse) Unmarshal(dAtA []byte) error {
 			return fmt.Errorf("proto: ExecProcessResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType)
-			}
-			m.Pid = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowShim
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Pid |= (uint32(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipShim(dAtA[iNdEx:])
@@ -3935,6 +4024,183 @@ func (m *UpdateTaskRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *StartRequest) 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 ErrIntOverflowShim
+			}
+			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: StartRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: StartRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowShim
+				}
+				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 ErrInvalidLengthShim
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ID = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipShim(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthShim
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *StartResponse) 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 ErrIntOverflowShim
+			}
+			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: StartResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: StartResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowShim
+				}
+				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 ErrInvalidLengthShim
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ID = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType)
+			}
+			m.Pid = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowShim
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Pid |= (uint32(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipShim(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthShim
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func skipShim(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0
@@ -4045,71 +4311,72 @@ func init() {
 }
 
 var fileDescriptorShim = []byte{
-	// 1049 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0x4f, 0x6f, 0xe3, 0x44,
-	0x14, 0x5f, 0xe7, 0xaf, 0xfb, 0x42, 0x4a, 0x3b, 0x94, 0xe2, 0xcd, 0x4a, 0x69, 0xe4, 0x43, 0x09,
-	0x42, 0x6b, 0xd3, 0x14, 0x76, 0xf9, 0x23, 0x21, 0xb5, 0xdd, 0x15, 0xaa, 0xa0, 0xda, 0xca, 0xdd,
-	0x05, 0x04, 0x42, 0x95, 0x1b, 0x4f, 0x93, 0x51, 0x1d, 0x8f, 0xd7, 0x33, 0x2e, 0x2d, 0x27, 0x4e,
-	0x9c, 0xf9, 0x38, 0x7c, 0x84, 0x1e, 0x91, 0xb8, 0x70, 0x5a, 0xd8, 0x9c, 0xb8, 0xf0, 0x1d, 0xd0,
-	0x8c, 0x27, 0x8d, 0x93, 0xd4, 0xb2, 0xc3, 0xa5, 0x9e, 0x37, 0xf3, 0x7b, 0x33, 0xef, 0xcd, 0xef,
-	0xcd, 0xef, 0x35, 0xf0, 0xc9, 0x80, 0xf0, 0x61, 0x7c, 0x66, 0xf5, 0xe9, 0xc8, 0xee, 0xd3, 0x80,
-	0xbb, 0x24, 0xc0, 0x91, 0x97, 0x1e, 0xfa, 0x24, 0x88, 0xaf, 0x6c, 0x36, 0x24, 0x23, 0xfb, 0x72,
-	0x47, 0x7e, 0xad, 0x30, 0xa2, 0x9c, 0xa2, 0xce, 0x14, 0x64, 0x45, 0x71, 0xc0, 0xc9, 0x08, 0x5b,
-	0x12, 0x6c, 0x49, 0xd0, 0xe5, 0x4e, 0xeb, 0xfe, 0x80, 0xd2, 0x81, 0x8f, 0x6d, 0x89, 0x3f, 0x8b,
-	0xcf, 0x6d, 0x37, 0xb8, 0x4e, 0x9c, 0x5b, 0x0f, 0xe6, 0x97, 0xf0, 0x28, 0xe4, 0x93, 0xc5, 0x8d,
-	0x01, 0x1d, 0x50, 0x39, 0xb4, 0xc5, 0x48, 0xcd, 0x6e, 0xcd, 0xbb, 0x88, 0x13, 0x19, 0x77, 0x47,
-	0xa1, 0x02, 0x3c, 0xca, 0xcd, 0xc5, 0x0d, 0x89, 0xcd, 0xaf, 0x43, 0xcc, 0xec, 0x11, 0x8d, 0x03,
-	0xae, 0xfc, 0x3e, 0x5d, 0xc2, 0x8f, 0xbb, 0xec, 0x42, 0xfe, 0x49, 0x7c, 0xcd, 0x7f, 0x4b, 0xb0,
-	0x7e, 0x10, 0x61, 0x97, 0xe3, 0xe7, 0x2e, 0xbb, 0x70, 0xf0, 0xcb, 0x18, 0x33, 0x8e, 0x36, 0xa1,
-	0x44, 0x3c, 0x43, 0xeb, 0x68, 0xdd, 0x95, 0xfd, 0xda, 0xf8, 0xd5, 0x56, 0xe9, 0xf0, 0x89, 0x53,
-	0x22, 0x1e, 0xda, 0x84, 0xda, 0x59, 0x1c, 0x78, 0x3e, 0x36, 0x4a, 0x62, 0xcd, 0x51, 0x16, 0x32,
-	0xa0, 0xae, 0x6e, 0xd0, 0x28, 0xcb, 0x85, 0x89, 0x89, 0x6c, 0xa8, 0x45, 0x94, 0xf2, 0x73, 0x66,
-	0x54, 0x3a, 0xe5, 0x6e, 0xa3, 0xf7, 0x8e, 0x95, 0xba, 0x75, 0x19, 0x92, 0x75, 0x24, 0x52, 0x71,
-	0x14, 0x0c, 0xb5, 0x40, 0xe7, 0x38, 0x1a, 0x91, 0xc0, 0xf5, 0x8d, 0x6a, 0x47, 0xeb, 0xea, 0xce,
-	0xad, 0x8d, 0x36, 0xa0, 0xca, 0xb8, 0x47, 0x02, 0xa3, 0x26, 0x0f, 0x49, 0x0c, 0x11, 0x14, 0xe3,
-	0x1e, 0x8d, 0xb9, 0x51, 0x4f, 0x82, 0x4a, 0x2c, 0x35, 0x8f, 0xa3, 0xc8, 0xd0, 0x6f, 0xe7, 0x71,
-	0x14, 0xa1, 0x36, 0x40, 0x7f, 0x88, 0xfb, 0x17, 0x21, 0x25, 0x01, 0x37, 0x56, 0xe4, 0x5a, 0x6a,
-	0x06, 0xbd, 0x0f, 0xeb, 0xa1, 0x1b, 0xe1, 0x80, 0x9f, 0xa6, 0x60, 0x20, 0x61, 0x6b, 0xc9, 0xc2,
-	0xc1, 0x14, 0x6c, 0x41, 0x9d, 0x86, 0x9c, 0xd0, 0x80, 0x19, 0x8d, 0x8e, 0xd6, 0x6d, 0xf4, 0x36,
-	0xac, 0x84, 0x66, 0x6b, 0x42, 0xb3, 0xb5, 0x17, 0x5c, 0x3b, 0x13, 0x90, 0xb9, 0x0d, 0x28, 0x7d,
-	0xdd, 0x2c, 0xa4, 0x01, 0xc3, 0x68, 0x0d, 0xca, 0xa1, 0xba, 0xf0, 0xa6, 0x23, 0x86, 0xe6, 0x2f,
-	0x1a, 0xac, 0x3e, 0xc1, 0x3e, 0xe6, 0x38, 0x1b, 0x84, 0xb6, 0xa0, 0x81, 0xaf, 0x08, 0x3f, 0x65,
-	0xdc, 0xe5, 0x31, 0x93, 0x9c, 0x34, 0x1d, 0x10, 0x53, 0x27, 0x72, 0x06, 0xed, 0xc1, 0x8a, 0xb0,
-	0xb0, 0x77, 0xea, 0x72, 0xc9, 0x4c, 0xa3, 0xd7, 0x5a, 0x88, 0xef, 0xf9, 0xa4, 0x0c, 0xf7, 0xf5,
-	0x9b, 0x57, 0x5b, 0xf7, 0x7e, 0xfd, 0x6b, 0x4b, 0x73, 0xf4, 0xc4, 0x6d, 0x8f, 0x9b, 0x16, 0x6c,
-	0x24, 0x71, 0x1c, 0x47, 0xb4, 0x8f, 0x19, 0xcb, 0x29, 0x11, 0xf3, 0x37, 0x0d, 0xd0, 0xd3, 0x2b,
-	0xdc, 0x2f, 0x06, 0x9f, 0xa1, 0xbb, 0x94, 0x45, 0x77, 0xf9, 0x6e, 0xba, 0x2b, 0x19, 0x74, 0x57,
-	0x67, 0xe8, 0xee, 0x42, 0x85, 0x85, 0xb8, 0x2f, 0x6b, 0x26, 0x8b, 0x1e, 0x89, 0x30, 0xdf, 0x85,
-	0xb7, 0x66, 0x22, 0xcf, 0x24, 0xe7, 0x5b, 0x58, 0x73, 0x30, 0x23, 0x3f, 0xe1, 0x63, 0x7e, 0x9d,
-	0x97, 0xe0, 0x06, 0x54, 0x7f, 0x24, 0x1e, 0x1f, 0x2a, 0x76, 0x12, 0x43, 0x04, 0x3b, 0xc4, 0x64,
-	0x30, 0x4c, 0x58, 0x69, 0x3a, 0xca, 0x32, 0xb7, 0xe1, 0x0d, 0x41, 0x1d, 0xce, 0xbb, 0xe5, 0x7f,
-	0x34, 0x68, 0x2a, 0xa0, 0x8a, 0x72, 0xd9, 0x27, 0xab, 0xb2, 0x2a, 0x4f, 0xab, 0x69, 0x57, 0x5c,
-	0xa0, 0x2c, 0x24, 0x71, 0xb1, 0xab, 0xbd, 0x07, 0xe9, 0xa7, 0x7a, 0xb9, 0xa3, 0x5e, 0x6b, 0x52,
-	0x59, 0x8e, 0x82, 0x4e, 0x39, 0xaa, 0xde, 0xcd, 0x51, 0x2d, 0x83, 0xa3, 0xfa, 0x0c, 0x47, 0xe9,
-	0x2a, 0xd0, 0x67, 0xab, 0xc0, 0x7c, 0x06, 0x8d, 0x2f, 0x89, 0xef, 0x17, 0x90, 0x26, 0x46, 0x06,
-	0x93, 0x32, 0x6a, 0x3a, 0xca, 0x12, 0x79, 0xba, 0xbe, 0x2f, 0xf3, 0xd4, 0x1d, 0x31, 0x34, 0x3f,
-	0x87, 0xd5, 0x03, 0x9f, 0x32, 0x7c, 0xf8, 0xac, 0x00, 0x77, 0x49, 0x72, 0x49, 0x65, 0x26, 0x86,
-	0xf9, 0x1e, 0xbc, 0xf9, 0x15, 0x61, 0xfc, 0x98, 0x78, 0xb9, 0x8f, 0x61, 0x1b, 0xd6, 0xa6, 0x50,
-	0x45, 0x14, 0x82, 0x4a, 0x48, 0x3c, 0x66, 0x68, 0x9d, 0x72, 0xb7, 0xe9, 0xc8, 0xb1, 0xf9, 0x3d,
-	0xbc, 0x3d, 0xd5, 0x94, 0xb4, 0x10, 0x0b, 0xb0, 0xcb, 0x87, 0xc9, 0xd6, 0x8e, 0x1c, 0xa7, 0x25,
-	0xa7, 0x54, 0x44, 0x72, 0x1e, 0xc2, 0xda, 0xc9, 0x90, 0x8c, 0x0e, 0x83, 0x73, 0x7a, 0x1b, 0xc4,
-	0x7d, 0xd0, 0x45, 0x93, 0x3b, 0x9d, 0x16, 0x76, 0x5d, 0xd8, 0xc7, 0xc4, 0x33, 0xbf, 0x80, 0xf5,
-	0x17, 0xa1, 0x37, 0xd7, 0x10, 0x7a, 0xb0, 0x12, 0x61, 0x46, 0xe3, 0xa8, 0x8f, 0x99, 0x74, 0xc8,
-	0x3a, 0x75, 0x0a, 0xeb, 0xfd, 0x01, 0x50, 0x11, 0x07, 0xa3, 0x21, 0x54, 0x65, 0xad, 0x22, 0xcb,
-	0xca, 0x6b, 0xb9, 0x56, 0xba, 0xfa, 0x5b, 0x76, 0x61, 0xbc, 0x4a, 0x8b, 0x41, 0x2d, 0x51, 0x57,
-	0xb4, 0x9b, 0xef, 0xba, 0xd0, 0xf6, 0x5a, 0x1f, 0x2e, 0xe7, 0xa4, 0x0e, 0x7d, 0x2c, 0xd3, 0x8b,
-	0x38, 0xda, 0x5c, 0xb8, 0x91, 0xa7, 0xe2, 0x9f, 0x82, 0x56, 0xc6, 0x3c, 0x72, 0xa0, 0x96, 0x48,
-	0x6b, 0xa6, 0xe7, 0x07, 0xf9, 0x01, 0xcd, 0x35, 0x89, 0x6b, 0x68, 0xce, 0xc8, 0x35, 0x7a, 0x54,
-	0x74, 0x8b, 0x59, 0xc1, 0xfe, 0x1f, 0x47, 0xbf, 0x04, 0x7d, 0x52, 0xec, 0x68, 0x27, 0xdf, 0x7b,
-	0xee, 0x0d, 0xb5, 0x7a, 0xcb, 0xb8, 0x4c, 0xaf, 0xfe, 0xd8, 0x8d, 0x19, 0x5e, 0xfa, 0xea, 0x3f,
-	0x86, 0x9a, 0x83, 0x59, 0x3c, 0x5a, 0xde, 0xf3, 0x07, 0x80, 0x54, 0xfb, 0x7f, 0x5c, 0xa0, 0x62,
-	0xee, 0x7a, 0xd8, 0x99, 0xdb, 0x1f, 0x41, 0x45, 0xa8, 0x1d, 0x7a, 0x98, 0xbf, 0x71, 0x4a, 0x15,
-	0x33, 0xb7, 0x63, 0x50, 0x11, 0x2d, 0x0d, 0x15, 0xa8, 0xec, 0xc5, 0xa6, 0xdd, 0xfa, 0x68, 0x49,
-	0x2f, 0xc5, 0xca, 0x37, 0xb0, 0x72, 0xdb, 0x1e, 0x51, 0x01, 0x5a, 0xe7, 0x7b, 0x69, 0x66, 0x36,
-	0x27, 0x50, 0x57, 0xca, 0x8d, 0x0a, 0x94, 0xe7, 0xac, 0xc8, 0x67, 0x6e, 0xfa, 0x35, 0xe8, 0x13,
-	0x79, 0xcc, 0x2c, 0x86, 0x02, 0x49, 0x2c, 0x48, 0xec, 0x0b, 0xa8, 0x25, 0x3a, 0x5a, 0x44, 0x8b,
-	0x16, 0x14, 0x37, 0x2b, 0xdc, 0xfd, 0xa3, 0x9b, 0xd7, 0xed, 0x7b, 0x7f, 0xbe, 0x6e, 0xdf, 0xfb,
-	0x79, 0xdc, 0xd6, 0x6e, 0xc6, 0x6d, 0xed, 0xf7, 0x71, 0x5b, 0xfb, 0x7b, 0xdc, 0xd6, 0xbe, 0xdb,
-	0x5d, 0xee, 0xa7, 0xd0, 0x67, 0xe2, 0x7b, 0x56, 0x93, 0xdb, 0xef, 0xfe, 0x17, 0x00, 0x00, 0xff,
-	0xff, 0xa3, 0x6e, 0xef, 0x88, 0x48, 0x0d, 0x00, 0x00,
+	// 1072 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0x5f, 0x6f, 0xe3, 0x44,
+	0x10, 0xaf, 0xf3, 0xbf, 0x13, 0x52, 0xda, 0xa5, 0x57, 0x7c, 0x39, 0x29, 0x8d, 0xfc, 0x50, 0x05,
+	0xa1, 0x73, 0x68, 0x8a, 0xee, 0x38, 0x90, 0x90, 0xda, 0xde, 0x09, 0x55, 0x50, 0x5d, 0xe5, 0xf6,
+	0x00, 0x81, 0x50, 0xe5, 0xc6, 0xdb, 0x64, 0xd5, 0xc4, 0xeb, 0xf3, 0xae, 0x4b, 0xcb, 0x13, 0x4f,
+	0x3c, 0xf3, 0x71, 0xf8, 0x08, 0x7d, 0xe4, 0x91, 0xa7, 0x83, 0x8b, 0x84, 0xc4, 0x0b, 0xdf, 0x01,
+	0xed, 0x9f, 0x24, 0x4e, 0x52, 0xcb, 0x0e, 0x2f, 0xcd, 0xce, 0xee, 0x6f, 0x66, 0x67, 0xe6, 0x37,
+	0x3b, 0xe3, 0xc2, 0xb3, 0x1e, 0xe1, 0xfd, 0xe8, 0xc2, 0xee, 0xd2, 0x61, 0xbb, 0x4b, 0x7d, 0xee,
+	0x12, 0x1f, 0x87, 0x5e, 0x7c, 0x39, 0x20, 0x7e, 0x74, 0xd3, 0x66, 0x7d, 0x32, 0x6c, 0x5f, 0xef,
+	0xca, 0x5f, 0x3b, 0x08, 0x29, 0xa7, 0xa8, 0x39, 0x05, 0xd9, 0x61, 0xe4, 0x73, 0x32, 0xc4, 0xb6,
+	0x04, 0xdb, 0x12, 0x74, 0xbd, 0x5b, 0x7f, 0xd8, 0xa3, 0xb4, 0x37, 0xc0, 0x6d, 0x89, 0xbf, 0x88,
+	0x2e, 0xdb, 0xae, 0x7f, 0xab, 0x94, 0xeb, 0x8f, 0xe6, 0x8f, 0xf0, 0x30, 0xe0, 0xe3, 0xc3, 0xcd,
+	0x1e, 0xed, 0x51, 0xb9, 0x6c, 0x8b, 0x95, 0xde, 0xdd, 0x9e, 0x57, 0x11, 0x37, 0x32, 0xee, 0x0e,
+	0x03, 0x0d, 0x78, 0x92, 0x1a, 0x8b, 0x1b, 0x90, 0x36, 0xbf, 0x0d, 0x30, 0x6b, 0x0f, 0x69, 0xe4,
+	0x73, 0xad, 0xf7, 0xe9, 0x12, 0x7a, 0xdc, 0x65, 0x57, 0xf2, 0x8f, 0xd2, 0xb5, 0xfe, 0xcd, 0xc1,
+	0xc6, 0x61, 0x88, 0x5d, 0x8e, 0xcf, 0x5c, 0x76, 0xe5, 0xe0, 0xd7, 0x11, 0x66, 0x1c, 0x6d, 0x41,
+	0x8e, 0x78, 0xa6, 0xd1, 0x34, 0x5a, 0xab, 0x07, 0xa5, 0xd1, 0x9b, 0xed, 0xdc, 0xd1, 0x73, 0x27,
+	0x47, 0x3c, 0xb4, 0x05, 0xa5, 0x8b, 0xc8, 0xf7, 0x06, 0xd8, 0xcc, 0x89, 0x33, 0x47, 0x4b, 0xc8,
+	0x84, 0xb2, 0xce, 0xa0, 0x99, 0x97, 0x07, 0x63, 0x11, 0xb5, 0xa1, 0x14, 0x52, 0xca, 0x2f, 0x99,
+	0x59, 0x68, 0xe6, 0x5b, 0xd5, 0xce, 0xfb, 0x76, 0x2c, 0xeb, 0xd2, 0x25, 0xfb, 0x58, 0x84, 0xe2,
+	0x68, 0x18, 0xaa, 0x43, 0x85, 0xe3, 0x70, 0x48, 0x7c, 0x77, 0x60, 0x16, 0x9b, 0x46, 0xab, 0xe2,
+	0x4c, 0x64, 0xb4, 0x09, 0x45, 0xc6, 0x3d, 0xe2, 0x9b, 0x25, 0x79, 0x89, 0x12, 0x84, 0x53, 0x8c,
+	0x7b, 0x34, 0xe2, 0x66, 0x59, 0x39, 0xa5, 0x24, 0xbd, 0x8f, 0xc3, 0xd0, 0xac, 0x4c, 0xf6, 0x71,
+	0x18, 0xa2, 0x06, 0x40, 0xb7, 0x8f, 0xbb, 0x57, 0x01, 0x25, 0x3e, 0x37, 0x57, 0xe5, 0x59, 0x6c,
+	0x07, 0x7d, 0x08, 0x1b, 0x81, 0x1b, 0x62, 0x9f, 0x9f, 0xc7, 0x60, 0x20, 0x61, 0xeb, 0xea, 0xe0,
+	0x70, 0x0a, 0xb6, 0xa1, 0x4c, 0x03, 0x4e, 0xa8, 0xcf, 0xcc, 0x6a, 0xd3, 0x68, 0x55, 0x3b, 0x9b,
+	0xb6, 0xa2, 0xd9, 0x1e, 0xd3, 0x6c, 0xef, 0xfb, 0xb7, 0xce, 0x18, 0x64, 0xed, 0x00, 0x8a, 0xa7,
+	0x9b, 0x05, 0xd4, 0x67, 0x18, 0xad, 0x43, 0x3e, 0xd0, 0x09, 0xaf, 0x39, 0x62, 0x69, 0xfd, 0x62,
+	0xc0, 0xda, 0x73, 0x3c, 0xc0, 0x1c, 0x27, 0x83, 0xd0, 0x36, 0x54, 0xf1, 0x0d, 0xe1, 0xe7, 0x8c,
+	0xbb, 0x3c, 0x62, 0x92, 0x93, 0x9a, 0x03, 0x62, 0xeb, 0x54, 0xee, 0xa0, 0x7d, 0x58, 0x15, 0x12,
+	0xf6, 0xce, 0x5d, 0x2e, 0x99, 0xa9, 0x76, 0xea, 0x0b, 0xfe, 0x9d, 0x8d, 0xcb, 0xf0, 0xa0, 0x72,
+	0xf7, 0x66, 0x7b, 0xe5, 0xd7, 0x3f, 0xb7, 0x0d, 0xa7, 0xa2, 0xd4, 0xf6, 0xb9, 0x65, 0xc3, 0xa6,
+	0xf2, 0xe3, 0x24, 0xa4, 0x5d, 0xcc, 0x58, 0x4a, 0x89, 0x58, 0xbf, 0x19, 0x80, 0x5e, 0xdc, 0xe0,
+	0x6e, 0x36, 0xf8, 0x0c, 0xdd, 0xb9, 0x24, 0xba, 0xf3, 0xf7, 0xd3, 0x5d, 0x48, 0xa0, 0xbb, 0x38,
+	0x43, 0x77, 0x0b, 0x0a, 0x2c, 0xc0, 0x5d, 0x59, 0x33, 0x49, 0xf4, 0x48, 0x84, 0xf5, 0x00, 0xde,
+	0x9b, 0xf1, 0x5c, 0xe5, 0xdd, 0xfa, 0x16, 0xd6, 0x1d, 0xcc, 0xc8, 0x4f, 0xf8, 0x84, 0xdf, 0xa6,
+	0x85, 0xb3, 0x09, 0xc5, 0x1f, 0x89, 0xc7, 0xfb, 0x9a, 0x0b, 0x25, 0x08, 0xd7, 0xfa, 0x98, 0xf4,
+	0xfa, 0x8a, 0x83, 0x9a, 0xa3, 0x25, 0x6b, 0x07, 0xde, 0x11, 0x44, 0xe1, 0xb4, 0x9c, 0xfe, 0x63,
+	0x40, 0x4d, 0x03, 0x75, 0x2d, 0x2c, 0xfb, 0x40, 0x75, 0xed, 0xe4, 0xa7, 0xb5, 0xb3, 0x27, 0xd2,
+	0x25, 0xcb, 0x46, 0xa4, 0x71, 0xad, 0xf3, 0x28, 0xfe, 0x30, 0xaf, 0x77, 0xf5, 0xdb, 0x54, 0x75,
+	0xe4, 0x68, 0xe8, 0x94, 0x91, 0xe2, 0xfd, 0x8c, 0x94, 0x12, 0x18, 0x29, 0xcf, 0x30, 0x12, 0xe7,
+	0xbc, 0x32, 0xcb, 0xb9, 0xf5, 0x12, 0xaa, 0x5f, 0x92, 0xc1, 0x20, 0x43, 0x23, 0x62, 0xa4, 0x37,
+	0x2e, 0x9a, 0x9a, 0xa3, 0x25, 0x11, 0xa7, 0x3b, 0x18, 0xc8, 0x38, 0x2b, 0x8e, 0x58, 0x5a, 0x9f,
+	0xc3, 0xda, 0xe1, 0x80, 0x32, 0x7c, 0xf4, 0x32, 0x03, 0x77, 0x2a, 0x38, 0x55, 0x87, 0x4a, 0xb0,
+	0x3e, 0x80, 0x77, 0xbf, 0x22, 0x8c, 0x9f, 0x10, 0x2f, 0xb5, 0xf4, 0x77, 0x60, 0x7d, 0x0a, 0xd5,
+	0x44, 0x21, 0x28, 0x04, 0xc4, 0x63, 0xa6, 0xd1, 0xcc, 0xb7, 0x6a, 0x8e, 0x5c, 0x5b, 0xdf, 0xc3,
+	0x83, 0x69, 0x07, 0x89, 0xb7, 0x5d, 0x01, 0x76, 0x79, 0x5f, 0x99, 0x76, 0xe4, 0x3a, 0xde, 0x60,
+	0x72, 0x59, 0x1a, 0xcc, 0x63, 0x58, 0x3f, 0xed, 0x93, 0xe1, 0x91, 0x7f, 0x49, 0x27, 0x4e, 0x3c,
+	0x84, 0x8a, 0x18, 0x69, 0xe7, 0xd3, 0xf6, 0x51, 0x16, 0xf2, 0x09, 0xf1, 0xac, 0x2f, 0x60, 0xe3,
+	0x55, 0xe0, 0xcd, 0xb5, 0xff, 0x0e, 0xac, 0x86, 0x98, 0xd1, 0x28, 0xec, 0x62, 0x26, 0x15, 0x92,
+	0x6e, 0x9d, 0xc2, 0x74, 0x2d, 0x87, 0x3c, 0x2d, 0x49, 0xcf, 0x64, 0x29, 0x0b, 0x5c, 0x4a, 0x29,
+	0xeb, 0x92, 0xcd, 0x4d, 0x4a, 0xb6, 0xf3, 0x37, 0x40, 0x41, 0xc4, 0x86, 0xfa, 0x50, 0x94, 0xcf,
+	0x01, 0xd9, 0x76, 0xda, 0x0c, 0xb7, 0xe3, 0x0f, 0xac, 0xde, 0xce, 0x8c, 0xd7, 0xce, 0x31, 0x28,
+	0xa9, 0x76, 0x8d, 0xf6, 0xd2, 0x55, 0x17, 0xe6, 0x68, 0xfd, 0xe3, 0xe5, 0x94, 0xf4, 0xa5, 0x2a,
+	0xbc, 0x90, 0x67, 0x0c, 0x6f, 0x92, 0xf3, 0x8c, 0xe1, 0xc5, 0x72, 0xef, 0x40, 0x49, 0x35, 0x77,
+	0xb4, 0xb5, 0xc0, 0xef, 0x0b, 0xf1, 0x41, 0x53, 0xff, 0x28, 0xdd, 0xe4, 0xdc, 0x98, 0xba, 0x85,
+	0xda, 0xcc, 0xc0, 0x40, 0x4f, 0xb2, 0x9a, 0x98, 0x1d, 0x19, 0xff, 0xe3, 0xea, 0xd7, 0x50, 0x19,
+	0x3f, 0x40, 0xb4, 0x9b, 0xae, 0x3d, 0xf7, 0xae, 0xeb, 0x9d, 0x65, 0x54, 0xf4, 0x95, 0x4f, 0xa1,
+	0x78, 0xe2, 0x46, 0x2c, 0x39, 0x81, 0x09, 0xfb, 0xe8, 0x13, 0x28, 0x39, 0x98, 0x45, 0xc3, 0xe5,
+	0x35, 0x7f, 0x00, 0x88, 0x7d, 0x80, 0x3c, 0xcd, 0x50, 0x62, 0xf7, 0x35, 0x9b, 0x44, 0xf3, 0xc7,
+	0x50, 0x10, 0x1d, 0x18, 0x3d, 0x4e, 0x37, 0x1c, 0xeb, 0xd4, 0x89, 0xe6, 0xce, 0xa0, 0x20, 0x86,
+	0x2a, 0xca, 0xf0, 0x14, 0x16, 0x3f, 0x1b, 0x12, 0xad, 0x7e, 0x03, 0xab, 0x93, 0x99, 0x8c, 0x32,
+	0xf0, 0x36, 0x3f, 0xc0, 0x13, 0x0d, 0x9f, 0x42, 0x59, 0x8f, 0x0b, 0x94, 0xa1, 0xfe, 0x66, 0x27,
+	0x4b, 0xa2, 0xd1, 0xaf, 0xa1, 0x32, 0xee, 0xc9, 0x89, 0x6c, 0x67, 0x08, 0x62, 0xa1, 0xaf, 0xbf,
+	0x82, 0x92, 0x6a, 0xde, 0x59, 0xba, 0xd3, 0x42, 0x9b, 0x4f, 0x72, 0xf7, 0xe0, 0xf8, 0xee, 0x6d,
+	0x63, 0xe5, 0x8f, 0xb7, 0x8d, 0x95, 0x9f, 0x47, 0x0d, 0xe3, 0x6e, 0xd4, 0x30, 0x7e, 0x1f, 0x35,
+	0x8c, 0xbf, 0x46, 0x0d, 0xe3, 0xbb, 0xbd, 0xe5, 0xfe, 0xdb, 0xfa, 0x4c, 0xfc, 0x5e, 0x94, 0xa4,
+	0xf9, 0xbd, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x05, 0x95, 0x8a, 0x43, 0xab, 0x0d, 0x00, 0x00,
 }

linux/shim/v1/shim.proto

@@ -21,7 +21,7 @@ service Shim {
 
 	rpc Create(CreateTaskRequest) returns (CreateTaskResponse);
 
-	rpc Start(google.protobuf.Empty) returns (google.protobuf.Empty);
+	rpc Start(StartRequest) returns (StartResponse);
 
 	rpc Delete(google.protobuf.Empty) returns (DeleteResponse);
 
@@ -37,7 +37,7 @@ service Shim {
 
 	rpc Kill(KillRequest) returns (google.protobuf.Empty);
 
-	rpc Exec(ExecProcessRequest) returns (ExecProcessResponse);
+	rpc Exec(ExecProcessRequest) returns (google.protobuf.Empty);
 
 	rpc ResizePty(ResizePtyRequest) returns (google.protobuf.Empty);
 
@@ -87,7 +87,6 @@ message ExecProcessRequest {
 }
 
 message ExecProcessResponse {
-	uint32 pid = 1;
 }
 
 message ResizePtyRequest {
@@ -142,3 +141,12 @@ message ShimInfoResponse {
 message UpdateTaskRequest {
 	google.protobuf.Any resources = 1;
 }
+
+message StartRequest {
+	string id = 1;
+}
+
+message StartResponse {
+	string id = 1;
+	uint32 pid = 2;
+}

linux/task.go

@@ -40,11 +40,13 @@ func (t *Task) Info() runtime.TaskInfo {
 }
 
 func (t *Task) Start(ctx context.Context) error {
-	_, err := t.shim.Start(ctx, empty)
+	_, err := t.shim.Start(ctx, &shim.StartRequest{
+		ID: t.id,
+	})
 	if err != nil {
-		err = errdefs.FromGRPC(err)
+		return errdefs.FromGRPC(err)
 	}
-	return err
+	return nil
 }
 
 func (t *Task) State(ctx context.Context) (runtime.State, error) {
@@ -116,6 +118,11 @@ func (t *Task) Exec(ctx context.Context, id string, opts runtime.ExecOpts) (runt
 	if _, err := t.shim.Exec(ctx, request); err != nil {
 		return nil, errdefs.FromGRPC(err)
 	}
+	if _, err := t.shim.Start(ctx, &shim.StartRequest{
+		ID: id,
+	}); err != nil {
+		return nil, errdefs.FromGRPC(err)
+	}
 	return &Process{
 		id: id,
 		t:  t,