1// Code generated by protoc-gen-gogo. DO NOT EDIT.
2// source: github.com/containerd/containerd/runtime/v1/shim/v1/shim.proto
3
4package shim
5
6import (
7	context "context"
8	fmt "fmt"
9	types "github.com/containerd/containerd/api/types"
10	task "github.com/containerd/containerd/api/types/task"
11	github_com_containerd_ttrpc "github.com/containerd/ttrpc"
12	proto "github.com/gogo/protobuf/proto"
13	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
14	types1 "github.com/gogo/protobuf/types"
15	io "io"
16	math "math"
17	math_bits "math/bits"
18	reflect "reflect"
19	strings "strings"
20	time "time"
21)
22
23// Reference imports to suppress errors if they are not otherwise used.
24var _ = proto.Marshal
25var _ = fmt.Errorf
26var _ = math.Inf
27var _ = time.Kitchen
28
29// This is a compile-time assertion to ensure that this generated file
30// is compatible with the proto package it is being compiled against.
31// A compilation error at this line likely means your copy of the
32// proto package needs to be updated.
33const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
34
35type CreateTaskRequest struct {
36	ID                   string         `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
37	Bundle               string         `protobuf:"bytes,2,opt,name=bundle,proto3" json:"bundle,omitempty"`
38	Runtime              string         `protobuf:"bytes,3,opt,name=runtime,proto3" json:"runtime,omitempty"`
39	Rootfs               []*types.Mount `protobuf:"bytes,4,rep,name=rootfs,proto3" json:"rootfs,omitempty"`
40	Terminal             bool           `protobuf:"varint,5,opt,name=terminal,proto3" json:"terminal,omitempty"`
41	Stdin                string         `protobuf:"bytes,6,opt,name=stdin,proto3" json:"stdin,omitempty"`
42	Stdout               string         `protobuf:"bytes,7,opt,name=stdout,proto3" json:"stdout,omitempty"`
43	Stderr               string         `protobuf:"bytes,8,opt,name=stderr,proto3" json:"stderr,omitempty"`
44	Checkpoint           string         `protobuf:"bytes,9,opt,name=checkpoint,proto3" json:"checkpoint,omitempty"`
45	ParentCheckpoint     string         `protobuf:"bytes,10,opt,name=parent_checkpoint,json=parentCheckpoint,proto3" json:"parent_checkpoint,omitempty"`
46	Options              *types1.Any    `protobuf:"bytes,11,opt,name=options,proto3" json:"options,omitempty"`
47	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
48	XXX_unrecognized     []byte         `json:"-"`
49	XXX_sizecache        int32          `json:"-"`
50}
51
52func (m *CreateTaskRequest) Reset()      { *m = CreateTaskRequest{} }
53func (*CreateTaskRequest) ProtoMessage() {}
54func (*CreateTaskRequest) Descriptor() ([]byte, []int) {
55	return fileDescriptor_be1b2ef30ea3b8ef, []int{0}
56}
57func (m *CreateTaskRequest) XXX_Unmarshal(b []byte) error {
58	return m.Unmarshal(b)
59}
60func (m *CreateTaskRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
61	if deterministic {
62		return xxx_messageInfo_CreateTaskRequest.Marshal(b, m, deterministic)
63	} else {
64		b = b[:cap(b)]
65		n, err := m.MarshalToSizedBuffer(b)
66		if err != nil {
67			return nil, err
68		}
69		return b[:n], nil
70	}
71}
72func (m *CreateTaskRequest) XXX_Merge(src proto.Message) {
73	xxx_messageInfo_CreateTaskRequest.Merge(m, src)
74}
75func (m *CreateTaskRequest) XXX_Size() int {
76	return m.Size()
77}
78func (m *CreateTaskRequest) XXX_DiscardUnknown() {
79	xxx_messageInfo_CreateTaskRequest.DiscardUnknown(m)
80}
81
82var xxx_messageInfo_CreateTaskRequest proto.InternalMessageInfo
83
84type CreateTaskResponse struct {
85	Pid                  uint32   `protobuf:"varint,1,opt,name=pid,proto3" json:"pid,omitempty"`
86	XXX_NoUnkeyedLiteral struct{} `json:"-"`
87	XXX_unrecognized     []byte   `json:"-"`
88	XXX_sizecache        int32    `json:"-"`
89}
90
91func (m *CreateTaskResponse) Reset()      { *m = CreateTaskResponse{} }
92func (*CreateTaskResponse) ProtoMessage() {}
93func (*CreateTaskResponse) Descriptor() ([]byte, []int) {
94	return fileDescriptor_be1b2ef30ea3b8ef, []int{1}
95}
96func (m *CreateTaskResponse) XXX_Unmarshal(b []byte) error {
97	return m.Unmarshal(b)
98}
99func (m *CreateTaskResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
100	if deterministic {
101		return xxx_messageInfo_CreateTaskResponse.Marshal(b, m, deterministic)
102	} else {
103		b = b[:cap(b)]
104		n, err := m.MarshalToSizedBuffer(b)
105		if err != nil {
106			return nil, err
107		}
108		return b[:n], nil
109	}
110}
111func (m *CreateTaskResponse) XXX_Merge(src proto.Message) {
112	xxx_messageInfo_CreateTaskResponse.Merge(m, src)
113}
114func (m *CreateTaskResponse) XXX_Size() int {
115	return m.Size()
116}
117func (m *CreateTaskResponse) XXX_DiscardUnknown() {
118	xxx_messageInfo_CreateTaskResponse.DiscardUnknown(m)
119}
120
121var xxx_messageInfo_CreateTaskResponse proto.InternalMessageInfo
122
123type DeleteResponse struct {
124	Pid                  uint32    `protobuf:"varint,1,opt,name=pid,proto3" json:"pid,omitempty"`
125	ExitStatus           uint32    `protobuf:"varint,2,opt,name=exit_status,json=exitStatus,proto3" json:"exit_status,omitempty"`
126	ExitedAt             time.Time `protobuf:"bytes,3,opt,name=exited_at,json=exitedAt,proto3,stdtime" json:"exited_at"`
127	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
128	XXX_unrecognized     []byte    `json:"-"`
129	XXX_sizecache        int32     `json:"-"`
130}
131
132func (m *DeleteResponse) Reset()      { *m = DeleteResponse{} }
133func (*DeleteResponse) ProtoMessage() {}
134func (*DeleteResponse) Descriptor() ([]byte, []int) {
135	return fileDescriptor_be1b2ef30ea3b8ef, []int{2}
136}
137func (m *DeleteResponse) XXX_Unmarshal(b []byte) error {
138	return m.Unmarshal(b)
139}
140func (m *DeleteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
141	if deterministic {
142		return xxx_messageInfo_DeleteResponse.Marshal(b, m, deterministic)
143	} else {
144		b = b[:cap(b)]
145		n, err := m.MarshalToSizedBuffer(b)
146		if err != nil {
147			return nil, err
148		}
149		return b[:n], nil
150	}
151}
152func (m *DeleteResponse) XXX_Merge(src proto.Message) {
153	xxx_messageInfo_DeleteResponse.Merge(m, src)
154}
155func (m *DeleteResponse) XXX_Size() int {
156	return m.Size()
157}
158func (m *DeleteResponse) XXX_DiscardUnknown() {
159	xxx_messageInfo_DeleteResponse.DiscardUnknown(m)
160}
161
162var xxx_messageInfo_DeleteResponse proto.InternalMessageInfo
163
164type DeleteProcessRequest struct {
165	ID                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
166	XXX_NoUnkeyedLiteral struct{} `json:"-"`
167	XXX_unrecognized     []byte   `json:"-"`
168	XXX_sizecache        int32    `json:"-"`
169}
170
171func (m *DeleteProcessRequest) Reset()      { *m = DeleteProcessRequest{} }
172func (*DeleteProcessRequest) ProtoMessage() {}
173func (*DeleteProcessRequest) Descriptor() ([]byte, []int) {
174	return fileDescriptor_be1b2ef30ea3b8ef, []int{3}
175}
176func (m *DeleteProcessRequest) XXX_Unmarshal(b []byte) error {
177	return m.Unmarshal(b)
178}
179func (m *DeleteProcessRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
180	if deterministic {
181		return xxx_messageInfo_DeleteProcessRequest.Marshal(b, m, deterministic)
182	} else {
183		b = b[:cap(b)]
184		n, err := m.MarshalToSizedBuffer(b)
185		if err != nil {
186			return nil, err
187		}
188		return b[:n], nil
189	}
190}
191func (m *DeleteProcessRequest) XXX_Merge(src proto.Message) {
192	xxx_messageInfo_DeleteProcessRequest.Merge(m, src)
193}
194func (m *DeleteProcessRequest) XXX_Size() int {
195	return m.Size()
196}
197func (m *DeleteProcessRequest) XXX_DiscardUnknown() {
198	xxx_messageInfo_DeleteProcessRequest.DiscardUnknown(m)
199}
200
201var xxx_messageInfo_DeleteProcessRequest proto.InternalMessageInfo
202
203type ExecProcessRequest struct {
204	ID                   string      `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
205	Terminal             bool        `protobuf:"varint,2,opt,name=terminal,proto3" json:"terminal,omitempty"`
206	Stdin                string      `protobuf:"bytes,3,opt,name=stdin,proto3" json:"stdin,omitempty"`
207	Stdout               string      `protobuf:"bytes,4,opt,name=stdout,proto3" json:"stdout,omitempty"`
208	Stderr               string      `protobuf:"bytes,5,opt,name=stderr,proto3" json:"stderr,omitempty"`
209	Spec                 *types1.Any `protobuf:"bytes,6,opt,name=spec,proto3" json:"spec,omitempty"`
210	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
211	XXX_unrecognized     []byte      `json:"-"`
212	XXX_sizecache        int32       `json:"-"`
213}
214
215func (m *ExecProcessRequest) Reset()      { *m = ExecProcessRequest{} }
216func (*ExecProcessRequest) ProtoMessage() {}
217func (*ExecProcessRequest) Descriptor() ([]byte, []int) {
218	return fileDescriptor_be1b2ef30ea3b8ef, []int{4}
219}
220func (m *ExecProcessRequest) XXX_Unmarshal(b []byte) error {
221	return m.Unmarshal(b)
222}
223func (m *ExecProcessRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
224	if deterministic {
225		return xxx_messageInfo_ExecProcessRequest.Marshal(b, m, deterministic)
226	} else {
227		b = b[:cap(b)]
228		n, err := m.MarshalToSizedBuffer(b)
229		if err != nil {
230			return nil, err
231		}
232		return b[:n], nil
233	}
234}
235func (m *ExecProcessRequest) XXX_Merge(src proto.Message) {
236	xxx_messageInfo_ExecProcessRequest.Merge(m, src)
237}
238func (m *ExecProcessRequest) XXX_Size() int {
239	return m.Size()
240}
241func (m *ExecProcessRequest) XXX_DiscardUnknown() {
242	xxx_messageInfo_ExecProcessRequest.DiscardUnknown(m)
243}
244
245var xxx_messageInfo_ExecProcessRequest proto.InternalMessageInfo
246
247type ExecProcessResponse struct {
248	XXX_NoUnkeyedLiteral struct{} `json:"-"`
249	XXX_unrecognized     []byte   `json:"-"`
250	XXX_sizecache        int32    `json:"-"`
251}
252
253func (m *ExecProcessResponse) Reset()      { *m = ExecProcessResponse{} }
254func (*ExecProcessResponse) ProtoMessage() {}
255func (*ExecProcessResponse) Descriptor() ([]byte, []int) {
256	return fileDescriptor_be1b2ef30ea3b8ef, []int{5}
257}
258func (m *ExecProcessResponse) XXX_Unmarshal(b []byte) error {
259	return m.Unmarshal(b)
260}
261func (m *ExecProcessResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
262	if deterministic {
263		return xxx_messageInfo_ExecProcessResponse.Marshal(b, m, deterministic)
264	} else {
265		b = b[:cap(b)]
266		n, err := m.MarshalToSizedBuffer(b)
267		if err != nil {
268			return nil, err
269		}
270		return b[:n], nil
271	}
272}
273func (m *ExecProcessResponse) XXX_Merge(src proto.Message) {
274	xxx_messageInfo_ExecProcessResponse.Merge(m, src)
275}
276func (m *ExecProcessResponse) XXX_Size() int {
277	return m.Size()
278}
279func (m *ExecProcessResponse) XXX_DiscardUnknown() {
280	xxx_messageInfo_ExecProcessResponse.DiscardUnknown(m)
281}
282
283var xxx_messageInfo_ExecProcessResponse proto.InternalMessageInfo
284
285type ResizePtyRequest struct {
286	ID                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
287	Width                uint32   `protobuf:"varint,2,opt,name=width,proto3" json:"width,omitempty"`
288	Height               uint32   `protobuf:"varint,3,opt,name=height,proto3" json:"height,omitempty"`
289	XXX_NoUnkeyedLiteral struct{} `json:"-"`
290	XXX_unrecognized     []byte   `json:"-"`
291	XXX_sizecache        int32    `json:"-"`
292}
293
294func (m *ResizePtyRequest) Reset()      { *m = ResizePtyRequest{} }
295func (*ResizePtyRequest) ProtoMessage() {}
296func (*ResizePtyRequest) Descriptor() ([]byte, []int) {
297	return fileDescriptor_be1b2ef30ea3b8ef, []int{6}
298}
299func (m *ResizePtyRequest) XXX_Unmarshal(b []byte) error {
300	return m.Unmarshal(b)
301}
302func (m *ResizePtyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
303	if deterministic {
304		return xxx_messageInfo_ResizePtyRequest.Marshal(b, m, deterministic)
305	} else {
306		b = b[:cap(b)]
307		n, err := m.MarshalToSizedBuffer(b)
308		if err != nil {
309			return nil, err
310		}
311		return b[:n], nil
312	}
313}
314func (m *ResizePtyRequest) XXX_Merge(src proto.Message) {
315	xxx_messageInfo_ResizePtyRequest.Merge(m, src)
316}
317func (m *ResizePtyRequest) XXX_Size() int {
318	return m.Size()
319}
320func (m *ResizePtyRequest) XXX_DiscardUnknown() {
321	xxx_messageInfo_ResizePtyRequest.DiscardUnknown(m)
322}
323
324var xxx_messageInfo_ResizePtyRequest proto.InternalMessageInfo
325
326type StateRequest struct {
327	ID                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
328	XXX_NoUnkeyedLiteral struct{} `json:"-"`
329	XXX_unrecognized     []byte   `json:"-"`
330	XXX_sizecache        int32    `json:"-"`
331}
332
333func (m *StateRequest) Reset()      { *m = StateRequest{} }
334func (*StateRequest) ProtoMessage() {}
335func (*StateRequest) Descriptor() ([]byte, []int) {
336	return fileDescriptor_be1b2ef30ea3b8ef, []int{7}
337}
338func (m *StateRequest) XXX_Unmarshal(b []byte) error {
339	return m.Unmarshal(b)
340}
341func (m *StateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
342	if deterministic {
343		return xxx_messageInfo_StateRequest.Marshal(b, m, deterministic)
344	} else {
345		b = b[:cap(b)]
346		n, err := m.MarshalToSizedBuffer(b)
347		if err != nil {
348			return nil, err
349		}
350		return b[:n], nil
351	}
352}
353func (m *StateRequest) XXX_Merge(src proto.Message) {
354	xxx_messageInfo_StateRequest.Merge(m, src)
355}
356func (m *StateRequest) XXX_Size() int {
357	return m.Size()
358}
359func (m *StateRequest) XXX_DiscardUnknown() {
360	xxx_messageInfo_StateRequest.DiscardUnknown(m)
361}
362
363var xxx_messageInfo_StateRequest proto.InternalMessageInfo
364
365type StateResponse struct {
366	ID                   string      `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
367	Bundle               string      `protobuf:"bytes,2,opt,name=bundle,proto3" json:"bundle,omitempty"`
368	Pid                  uint32      `protobuf:"varint,3,opt,name=pid,proto3" json:"pid,omitempty"`
369	Status               task.Status `protobuf:"varint,4,opt,name=status,proto3,enum=containerd.v1.types.Status" json:"status,omitempty"`
370	Stdin                string      `protobuf:"bytes,5,opt,name=stdin,proto3" json:"stdin,omitempty"`
371	Stdout               string      `protobuf:"bytes,6,opt,name=stdout,proto3" json:"stdout,omitempty"`
372	Stderr               string      `protobuf:"bytes,7,opt,name=stderr,proto3" json:"stderr,omitempty"`
373	Terminal             bool        `protobuf:"varint,8,opt,name=terminal,proto3" json:"terminal,omitempty"`
374	ExitStatus           uint32      `protobuf:"varint,9,opt,name=exit_status,json=exitStatus,proto3" json:"exit_status,omitempty"`
375	ExitedAt             time.Time   `protobuf:"bytes,10,opt,name=exited_at,json=exitedAt,proto3,stdtime" json:"exited_at"`
376	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
377	XXX_unrecognized     []byte      `json:"-"`
378	XXX_sizecache        int32       `json:"-"`
379}
380
381func (m *StateResponse) Reset()      { *m = StateResponse{} }
382func (*StateResponse) ProtoMessage() {}
383func (*StateResponse) Descriptor() ([]byte, []int) {
384	return fileDescriptor_be1b2ef30ea3b8ef, []int{8}
385}
386func (m *StateResponse) XXX_Unmarshal(b []byte) error {
387	return m.Unmarshal(b)
388}
389func (m *StateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
390	if deterministic {
391		return xxx_messageInfo_StateResponse.Marshal(b, m, deterministic)
392	} else {
393		b = b[:cap(b)]
394		n, err := m.MarshalToSizedBuffer(b)
395		if err != nil {
396			return nil, err
397		}
398		return b[:n], nil
399	}
400}
401func (m *StateResponse) XXX_Merge(src proto.Message) {
402	xxx_messageInfo_StateResponse.Merge(m, src)
403}
404func (m *StateResponse) XXX_Size() int {
405	return m.Size()
406}
407func (m *StateResponse) XXX_DiscardUnknown() {
408	xxx_messageInfo_StateResponse.DiscardUnknown(m)
409}
410
411var xxx_messageInfo_StateResponse proto.InternalMessageInfo
412
413type KillRequest struct {
414	ID                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
415	Signal               uint32   `protobuf:"varint,2,opt,name=signal,proto3" json:"signal,omitempty"`
416	All                  bool     `protobuf:"varint,3,opt,name=all,proto3" json:"all,omitempty"`
417	XXX_NoUnkeyedLiteral struct{} `json:"-"`
418	XXX_unrecognized     []byte   `json:"-"`
419	XXX_sizecache        int32    `json:"-"`
420}
421
422func (m *KillRequest) Reset()      { *m = KillRequest{} }
423func (*KillRequest) ProtoMessage() {}
424func (*KillRequest) Descriptor() ([]byte, []int) {
425	return fileDescriptor_be1b2ef30ea3b8ef, []int{9}
426}
427func (m *KillRequest) XXX_Unmarshal(b []byte) error {
428	return m.Unmarshal(b)
429}
430func (m *KillRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
431	if deterministic {
432		return xxx_messageInfo_KillRequest.Marshal(b, m, deterministic)
433	} else {
434		b = b[:cap(b)]
435		n, err := m.MarshalToSizedBuffer(b)
436		if err != nil {
437			return nil, err
438		}
439		return b[:n], nil
440	}
441}
442func (m *KillRequest) XXX_Merge(src proto.Message) {
443	xxx_messageInfo_KillRequest.Merge(m, src)
444}
445func (m *KillRequest) XXX_Size() int {
446	return m.Size()
447}
448func (m *KillRequest) XXX_DiscardUnknown() {
449	xxx_messageInfo_KillRequest.DiscardUnknown(m)
450}
451
452var xxx_messageInfo_KillRequest proto.InternalMessageInfo
453
454type CloseIORequest struct {
455	ID                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
456	Stdin                bool     `protobuf:"varint,2,opt,name=stdin,proto3" json:"stdin,omitempty"`
457	XXX_NoUnkeyedLiteral struct{} `json:"-"`
458	XXX_unrecognized     []byte   `json:"-"`
459	XXX_sizecache        int32    `json:"-"`
460}
461
462func (m *CloseIORequest) Reset()      { *m = CloseIORequest{} }
463func (*CloseIORequest) ProtoMessage() {}
464func (*CloseIORequest) Descriptor() ([]byte, []int) {
465	return fileDescriptor_be1b2ef30ea3b8ef, []int{10}
466}
467func (m *CloseIORequest) XXX_Unmarshal(b []byte) error {
468	return m.Unmarshal(b)
469}
470func (m *CloseIORequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
471	if deterministic {
472		return xxx_messageInfo_CloseIORequest.Marshal(b, m, deterministic)
473	} else {
474		b = b[:cap(b)]
475		n, err := m.MarshalToSizedBuffer(b)
476		if err != nil {
477			return nil, err
478		}
479		return b[:n], nil
480	}
481}
482func (m *CloseIORequest) XXX_Merge(src proto.Message) {
483	xxx_messageInfo_CloseIORequest.Merge(m, src)
484}
485func (m *CloseIORequest) XXX_Size() int {
486	return m.Size()
487}
488func (m *CloseIORequest) XXX_DiscardUnknown() {
489	xxx_messageInfo_CloseIORequest.DiscardUnknown(m)
490}
491
492var xxx_messageInfo_CloseIORequest proto.InternalMessageInfo
493
494type ListPidsRequest struct {
495	ID                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
496	XXX_NoUnkeyedLiteral struct{} `json:"-"`
497	XXX_unrecognized     []byte   `json:"-"`
498	XXX_sizecache        int32    `json:"-"`
499}
500
501func (m *ListPidsRequest) Reset()      { *m = ListPidsRequest{} }
502func (*ListPidsRequest) ProtoMessage() {}
503func (*ListPidsRequest) Descriptor() ([]byte, []int) {
504	return fileDescriptor_be1b2ef30ea3b8ef, []int{11}
505}
506func (m *ListPidsRequest) XXX_Unmarshal(b []byte) error {
507	return m.Unmarshal(b)
508}
509func (m *ListPidsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
510	if deterministic {
511		return xxx_messageInfo_ListPidsRequest.Marshal(b, m, deterministic)
512	} else {
513		b = b[:cap(b)]
514		n, err := m.MarshalToSizedBuffer(b)
515		if err != nil {
516			return nil, err
517		}
518		return b[:n], nil
519	}
520}
521func (m *ListPidsRequest) XXX_Merge(src proto.Message) {
522	xxx_messageInfo_ListPidsRequest.Merge(m, src)
523}
524func (m *ListPidsRequest) XXX_Size() int {
525	return m.Size()
526}
527func (m *ListPidsRequest) XXX_DiscardUnknown() {
528	xxx_messageInfo_ListPidsRequest.DiscardUnknown(m)
529}
530
531var xxx_messageInfo_ListPidsRequest proto.InternalMessageInfo
532
533type ListPidsResponse struct {
534	Processes            []*task.ProcessInfo `protobuf:"bytes,1,rep,name=processes,proto3" json:"processes,omitempty"`
535	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
536	XXX_unrecognized     []byte              `json:"-"`
537	XXX_sizecache        int32               `json:"-"`
538}
539
540func (m *ListPidsResponse) Reset()      { *m = ListPidsResponse{} }
541func (*ListPidsResponse) ProtoMessage() {}
542func (*ListPidsResponse) Descriptor() ([]byte, []int) {
543	return fileDescriptor_be1b2ef30ea3b8ef, []int{12}
544}
545func (m *ListPidsResponse) XXX_Unmarshal(b []byte) error {
546	return m.Unmarshal(b)
547}
548func (m *ListPidsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
549	if deterministic {
550		return xxx_messageInfo_ListPidsResponse.Marshal(b, m, deterministic)
551	} else {
552		b = b[:cap(b)]
553		n, err := m.MarshalToSizedBuffer(b)
554		if err != nil {
555			return nil, err
556		}
557		return b[:n], nil
558	}
559}
560func (m *ListPidsResponse) XXX_Merge(src proto.Message) {
561	xxx_messageInfo_ListPidsResponse.Merge(m, src)
562}
563func (m *ListPidsResponse) XXX_Size() int {
564	return m.Size()
565}
566func (m *ListPidsResponse) XXX_DiscardUnknown() {
567	xxx_messageInfo_ListPidsResponse.DiscardUnknown(m)
568}
569
570var xxx_messageInfo_ListPidsResponse proto.InternalMessageInfo
571
572type CheckpointTaskRequest struct {
573	Path                 string      `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
574	Options              *types1.Any `protobuf:"bytes,2,opt,name=options,proto3" json:"options,omitempty"`
575	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
576	XXX_unrecognized     []byte      `json:"-"`
577	XXX_sizecache        int32       `json:"-"`
578}
579
580func (m *CheckpointTaskRequest) Reset()      { *m = CheckpointTaskRequest{} }
581func (*CheckpointTaskRequest) ProtoMessage() {}
582func (*CheckpointTaskRequest) Descriptor() ([]byte, []int) {
583	return fileDescriptor_be1b2ef30ea3b8ef, []int{13}
584}
585func (m *CheckpointTaskRequest) XXX_Unmarshal(b []byte) error {
586	return m.Unmarshal(b)
587}
588func (m *CheckpointTaskRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
589	if deterministic {
590		return xxx_messageInfo_CheckpointTaskRequest.Marshal(b, m, deterministic)
591	} else {
592		b = b[:cap(b)]
593		n, err := m.MarshalToSizedBuffer(b)
594		if err != nil {
595			return nil, err
596		}
597		return b[:n], nil
598	}
599}
600func (m *CheckpointTaskRequest) XXX_Merge(src proto.Message) {
601	xxx_messageInfo_CheckpointTaskRequest.Merge(m, src)
602}
603func (m *CheckpointTaskRequest) XXX_Size() int {
604	return m.Size()
605}
606func (m *CheckpointTaskRequest) XXX_DiscardUnknown() {
607	xxx_messageInfo_CheckpointTaskRequest.DiscardUnknown(m)
608}
609
610var xxx_messageInfo_CheckpointTaskRequest proto.InternalMessageInfo
611
612type ShimInfoResponse struct {
613	ShimPid              uint32   `protobuf:"varint,1,opt,name=shim_pid,json=shimPid,proto3" json:"shim_pid,omitempty"`
614	XXX_NoUnkeyedLiteral struct{} `json:"-"`
615	XXX_unrecognized     []byte   `json:"-"`
616	XXX_sizecache        int32    `json:"-"`
617}
618
619func (m *ShimInfoResponse) Reset()      { *m = ShimInfoResponse{} }
620func (*ShimInfoResponse) ProtoMessage() {}
621func (*ShimInfoResponse) Descriptor() ([]byte, []int) {
622	return fileDescriptor_be1b2ef30ea3b8ef, []int{14}
623}
624func (m *ShimInfoResponse) XXX_Unmarshal(b []byte) error {
625	return m.Unmarshal(b)
626}
627func (m *ShimInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
628	if deterministic {
629		return xxx_messageInfo_ShimInfoResponse.Marshal(b, m, deterministic)
630	} else {
631		b = b[:cap(b)]
632		n, err := m.MarshalToSizedBuffer(b)
633		if err != nil {
634			return nil, err
635		}
636		return b[:n], nil
637	}
638}
639func (m *ShimInfoResponse) XXX_Merge(src proto.Message) {
640	xxx_messageInfo_ShimInfoResponse.Merge(m, src)
641}
642func (m *ShimInfoResponse) XXX_Size() int {
643	return m.Size()
644}
645func (m *ShimInfoResponse) XXX_DiscardUnknown() {
646	xxx_messageInfo_ShimInfoResponse.DiscardUnknown(m)
647}
648
649var xxx_messageInfo_ShimInfoResponse proto.InternalMessageInfo
650
651type UpdateTaskRequest struct {
652	Resources            *types1.Any `protobuf:"bytes,1,opt,name=resources,proto3" json:"resources,omitempty"`
653	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
654	XXX_unrecognized     []byte      `json:"-"`
655	XXX_sizecache        int32       `json:"-"`
656}
657
658func (m *UpdateTaskRequest) Reset()      { *m = UpdateTaskRequest{} }
659func (*UpdateTaskRequest) ProtoMessage() {}
660func (*UpdateTaskRequest) Descriptor() ([]byte, []int) {
661	return fileDescriptor_be1b2ef30ea3b8ef, []int{15}
662}
663func (m *UpdateTaskRequest) XXX_Unmarshal(b []byte) error {
664	return m.Unmarshal(b)
665}
666func (m *UpdateTaskRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
667	if deterministic {
668		return xxx_messageInfo_UpdateTaskRequest.Marshal(b, m, deterministic)
669	} else {
670		b = b[:cap(b)]
671		n, err := m.MarshalToSizedBuffer(b)
672		if err != nil {
673			return nil, err
674		}
675		return b[:n], nil
676	}
677}
678func (m *UpdateTaskRequest) XXX_Merge(src proto.Message) {
679	xxx_messageInfo_UpdateTaskRequest.Merge(m, src)
680}
681func (m *UpdateTaskRequest) XXX_Size() int {
682	return m.Size()
683}
684func (m *UpdateTaskRequest) XXX_DiscardUnknown() {
685	xxx_messageInfo_UpdateTaskRequest.DiscardUnknown(m)
686}
687
688var xxx_messageInfo_UpdateTaskRequest proto.InternalMessageInfo
689
690type StartRequest struct {
691	ID                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
692	XXX_NoUnkeyedLiteral struct{} `json:"-"`
693	XXX_unrecognized     []byte   `json:"-"`
694	XXX_sizecache        int32    `json:"-"`
695}
696
697func (m *StartRequest) Reset()      { *m = StartRequest{} }
698func (*StartRequest) ProtoMessage() {}
699func (*StartRequest) Descriptor() ([]byte, []int) {
700	return fileDescriptor_be1b2ef30ea3b8ef, []int{16}
701}
702func (m *StartRequest) XXX_Unmarshal(b []byte) error {
703	return m.Unmarshal(b)
704}
705func (m *StartRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
706	if deterministic {
707		return xxx_messageInfo_StartRequest.Marshal(b, m, deterministic)
708	} else {
709		b = b[:cap(b)]
710		n, err := m.MarshalToSizedBuffer(b)
711		if err != nil {
712			return nil, err
713		}
714		return b[:n], nil
715	}
716}
717func (m *StartRequest) XXX_Merge(src proto.Message) {
718	xxx_messageInfo_StartRequest.Merge(m, src)
719}
720func (m *StartRequest) XXX_Size() int {
721	return m.Size()
722}
723func (m *StartRequest) XXX_DiscardUnknown() {
724	xxx_messageInfo_StartRequest.DiscardUnknown(m)
725}
726
727var xxx_messageInfo_StartRequest proto.InternalMessageInfo
728
729type StartResponse struct {
730	ID                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
731	Pid                  uint32   `protobuf:"varint,2,opt,name=pid,proto3" json:"pid,omitempty"`
732	XXX_NoUnkeyedLiteral struct{} `json:"-"`
733	XXX_unrecognized     []byte   `json:"-"`
734	XXX_sizecache        int32    `json:"-"`
735}
736
737func (m *StartResponse) Reset()      { *m = StartResponse{} }
738func (*StartResponse) ProtoMessage() {}
739func (*StartResponse) Descriptor() ([]byte, []int) {
740	return fileDescriptor_be1b2ef30ea3b8ef, []int{17}
741}
742func (m *StartResponse) XXX_Unmarshal(b []byte) error {
743	return m.Unmarshal(b)
744}
745func (m *StartResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
746	if deterministic {
747		return xxx_messageInfo_StartResponse.Marshal(b, m, deterministic)
748	} else {
749		b = b[:cap(b)]
750		n, err := m.MarshalToSizedBuffer(b)
751		if err != nil {
752			return nil, err
753		}
754		return b[:n], nil
755	}
756}
757func (m *StartResponse) XXX_Merge(src proto.Message) {
758	xxx_messageInfo_StartResponse.Merge(m, src)
759}
760func (m *StartResponse) XXX_Size() int {
761	return m.Size()
762}
763func (m *StartResponse) XXX_DiscardUnknown() {
764	xxx_messageInfo_StartResponse.DiscardUnknown(m)
765}
766
767var xxx_messageInfo_StartResponse proto.InternalMessageInfo
768
769type WaitRequest struct {
770	ID                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
771	XXX_NoUnkeyedLiteral struct{} `json:"-"`
772	XXX_unrecognized     []byte   `json:"-"`
773	XXX_sizecache        int32    `json:"-"`
774}
775
776func (m *WaitRequest) Reset()      { *m = WaitRequest{} }
777func (*WaitRequest) ProtoMessage() {}
778func (*WaitRequest) Descriptor() ([]byte, []int) {
779	return fileDescriptor_be1b2ef30ea3b8ef, []int{18}
780}
781func (m *WaitRequest) XXX_Unmarshal(b []byte) error {
782	return m.Unmarshal(b)
783}
784func (m *WaitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
785	if deterministic {
786		return xxx_messageInfo_WaitRequest.Marshal(b, m, deterministic)
787	} else {
788		b = b[:cap(b)]
789		n, err := m.MarshalToSizedBuffer(b)
790		if err != nil {
791			return nil, err
792		}
793		return b[:n], nil
794	}
795}
796func (m *WaitRequest) XXX_Merge(src proto.Message) {
797	xxx_messageInfo_WaitRequest.Merge(m, src)
798}
799func (m *WaitRequest) XXX_Size() int {
800	return m.Size()
801}
802func (m *WaitRequest) XXX_DiscardUnknown() {
803	xxx_messageInfo_WaitRequest.DiscardUnknown(m)
804}
805
806var xxx_messageInfo_WaitRequest proto.InternalMessageInfo
807
808type WaitResponse struct {
809	ExitStatus           uint32    `protobuf:"varint,1,opt,name=exit_status,json=exitStatus,proto3" json:"exit_status,omitempty"`
810	ExitedAt             time.Time `protobuf:"bytes,2,opt,name=exited_at,json=exitedAt,proto3,stdtime" json:"exited_at"`
811	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
812	XXX_unrecognized     []byte    `json:"-"`
813	XXX_sizecache        int32     `json:"-"`
814}
815
816func (m *WaitResponse) Reset()      { *m = WaitResponse{} }
817func (*WaitResponse) ProtoMessage() {}
818func (*WaitResponse) Descriptor() ([]byte, []int) {
819	return fileDescriptor_be1b2ef30ea3b8ef, []int{19}
820}
821func (m *WaitResponse) XXX_Unmarshal(b []byte) error {
822	return m.Unmarshal(b)
823}
824func (m *WaitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
825	if deterministic {
826		return xxx_messageInfo_WaitResponse.Marshal(b, m, deterministic)
827	} else {
828		b = b[:cap(b)]
829		n, err := m.MarshalToSizedBuffer(b)
830		if err != nil {
831			return nil, err
832		}
833		return b[:n], nil
834	}
835}
836func (m *WaitResponse) XXX_Merge(src proto.Message) {
837	xxx_messageInfo_WaitResponse.Merge(m, src)
838}
839func (m *WaitResponse) XXX_Size() int {
840	return m.Size()
841}
842func (m *WaitResponse) XXX_DiscardUnknown() {
843	xxx_messageInfo_WaitResponse.DiscardUnknown(m)
844}
845
846var xxx_messageInfo_WaitResponse proto.InternalMessageInfo
847
848func init() {
849	proto.RegisterType((*CreateTaskRequest)(nil), "containerd.runtime.linux.shim.v1.CreateTaskRequest")
850	proto.RegisterType((*CreateTaskResponse)(nil), "containerd.runtime.linux.shim.v1.CreateTaskResponse")
851	proto.RegisterType((*DeleteResponse)(nil), "containerd.runtime.linux.shim.v1.DeleteResponse")
852	proto.RegisterType((*DeleteProcessRequest)(nil), "containerd.runtime.linux.shim.v1.DeleteProcessRequest")
853	proto.RegisterType((*ExecProcessRequest)(nil), "containerd.runtime.linux.shim.v1.ExecProcessRequest")
854	proto.RegisterType((*ExecProcessResponse)(nil), "containerd.runtime.linux.shim.v1.ExecProcessResponse")
855	proto.RegisterType((*ResizePtyRequest)(nil), "containerd.runtime.linux.shim.v1.ResizePtyRequest")
856	proto.RegisterType((*StateRequest)(nil), "containerd.runtime.linux.shim.v1.StateRequest")
857	proto.RegisterType((*StateResponse)(nil), "containerd.runtime.linux.shim.v1.StateResponse")
858	proto.RegisterType((*KillRequest)(nil), "containerd.runtime.linux.shim.v1.KillRequest")
859	proto.RegisterType((*CloseIORequest)(nil), "containerd.runtime.linux.shim.v1.CloseIORequest")
860	proto.RegisterType((*ListPidsRequest)(nil), "containerd.runtime.linux.shim.v1.ListPidsRequest")
861	proto.RegisterType((*ListPidsResponse)(nil), "containerd.runtime.linux.shim.v1.ListPidsResponse")
862	proto.RegisterType((*CheckpointTaskRequest)(nil), "containerd.runtime.linux.shim.v1.CheckpointTaskRequest")
863	proto.RegisterType((*ShimInfoResponse)(nil), "containerd.runtime.linux.shim.v1.ShimInfoResponse")
864	proto.RegisterType((*UpdateTaskRequest)(nil), "containerd.runtime.linux.shim.v1.UpdateTaskRequest")
865	proto.RegisterType((*StartRequest)(nil), "containerd.runtime.linux.shim.v1.StartRequest")
866	proto.RegisterType((*StartResponse)(nil), "containerd.runtime.linux.shim.v1.StartResponse")
867	proto.RegisterType((*WaitRequest)(nil), "containerd.runtime.linux.shim.v1.WaitRequest")
868	proto.RegisterType((*WaitResponse)(nil), "containerd.runtime.linux.shim.v1.WaitResponse")
869}
870
871func init() {
872	proto.RegisterFile("github.com/containerd/containerd/runtime/v1/shim/v1/shim.proto", fileDescriptor_be1b2ef30ea3b8ef)
873}
874
875var fileDescriptor_be1b2ef30ea3b8ef = []byte{
876	// 1133 bytes of a gzipped FileDescriptorProto
877	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0x4f, 0x4f, 0x1b, 0x47,
878	0x14, 0x67, 0x17, 0xff, 0x7d, 0x8e, 0x29, 0x4c, 0x09, 0xdd, 0x38, 0x92, 0xb1, 0x56, 0x6a, 0x44,
879	0x55, 0x65, 0x5d, 0x4c, 0x95, 0xa4, 0xad, 0x84, 0x04, 0x24, 0xaa, 0x50, 0x1b, 0x05, 0x2d, 0xa4,
880	0x89, 0x5a, 0x55, 0x68, 0xf1, 0x0e, 0xf6, 0x08, 0x7b, 0x67, 0xb3, 0x33, 0x4b, 0xa1, 0xa7, 0x9e,
881	0x7a, 0xee, 0xc7, 0xe9, 0x47, 0xe0, 0x90, 0x43, 0x8f, 0x3d, 0xa5, 0x0d, 0xf7, 0x7e, 0x87, 0x6a,
882	0xfe, 0x18, 0xaf, 0x6d, 0x36, 0xbb, 0x70, 0xc1, 0xfb, 0x66, 0x7e, 0x6f, 0xe6, 0xcd, 0xfb, 0xfd,
883	0xe6, 0xbd, 0x01, 0x36, 0x7b, 0x84, 0xf7, 0xe3, 0x23, 0xa7, 0x4b, 0x87, 0xed, 0x2e, 0x0d, 0xb8,
884	0x47, 0x02, 0x1c, 0xf9, 0xc9, 0xcf, 0x28, 0x0e, 0x38, 0x19, 0xe2, 0xf6, 0xe9, 0x7a, 0x9b, 0xf5,
885	0xc9, 0x70, 0xf4, 0xeb, 0x84, 0x11, 0xe5, 0x14, 0xb5, 0xc6, 0x48, 0x47, 0x23, 0x9d, 0x01, 0x09,
886	0xe2, 0x33, 0x47, 0x82, 0x4e, 0xd7, 0x1b, 0xf7, 0x7a, 0x94, 0xf6, 0x06, 0xb8, 0x2d, 0xf1, 0x47,
887	0xf1, 0x71, 0xdb, 0x0b, 0xce, 0x95, 0x73, 0xe3, 0xfe, 0xf4, 0x14, 0x1e, 0x86, 0x7c, 0x34, 0xb9,
888	0xdc, 0xa3, 0x3d, 0x2a, 0x3f, 0xdb, 0xe2, 0x4b, 0x8f, 0xae, 0x4e, 0xbb, 0x88, 0x1d, 0x19, 0xf7,
889	0x86, 0xa1, 0x06, 0x3c, 0xca, 0x3c, 0x90, 0x17, 0x92, 0x36, 0x3f, 0x0f, 0x31, 0x6b, 0x0f, 0x69,
890	0x1c, 0x70, 0xed, 0xf7, 0xf5, 0x0d, 0xfc, 0xb8, 0xc7, 0x4e, 0xe4, 0x1f, 0xe5, 0x6b, 0xff, 0x67,
891	0xc2, 0xd2, 0x4e, 0x84, 0x3d, 0x8e, 0x0f, 0x3c, 0x76, 0xe2, 0xe2, 0x37, 0x31, 0x66, 0x1c, 0xad,
892	0x80, 0x49, 0x7c, 0xcb, 0x68, 0x19, 0x6b, 0xd5, 0xed, 0xd2, 0xe5, 0xbb, 0x55, 0x73, 0xf7, 0xa9,
893	0x6b, 0x12, 0x1f, 0xad, 0x40, 0xe9, 0x28, 0x0e, 0xfc, 0x01, 0xb6, 0x4c, 0x31, 0xe7, 0x6a, 0x0b,
894	0x59, 0x50, 0xd6, 0x19, 0xb4, 0xe6, 0xe5, 0xc4, 0xc8, 0x44, 0x6d, 0x28, 0x45, 0x94, 0xf2, 0x63,
895	0x66, 0x15, 0x5a, 0xf3, 0x6b, 0xb5, 0xce, 0x27, 0x4e, 0x22, 0xeb, 0x32, 0x24, 0xe7, 0xb9, 0x38,
896	0x8a, 0xab, 0x61, 0xa8, 0x01, 0x15, 0x8e, 0xa3, 0x21, 0x09, 0xbc, 0x81, 0x55, 0x6c, 0x19, 0x6b,
897	0x15, 0xf7, 0xca, 0x46, 0xcb, 0x50, 0x64, 0xdc, 0x27, 0x81, 0x55, 0x92, 0x9b, 0x28, 0x43, 0x04,
898	0xc5, 0xb8, 0x4f, 0x63, 0x6e, 0x95, 0x55, 0x50, 0xca, 0xd2, 0xe3, 0x38, 0x8a, 0xac, 0xca, 0xd5,
899	0x38, 0x8e, 0x22, 0xd4, 0x04, 0xe8, 0xf6, 0x71, 0xf7, 0x24, 0xa4, 0x24, 0xe0, 0x56, 0x55, 0xce,
900	0x25, 0x46, 0xd0, 0xe7, 0xb0, 0x14, 0x7a, 0x11, 0x0e, 0xf8, 0x61, 0x02, 0x06, 0x12, 0xb6, 0xa8,
901	0x26, 0x76, 0xc6, 0x60, 0x07, 0xca, 0x34, 0xe4, 0x84, 0x06, 0xcc, 0xaa, 0xb5, 0x8c, 0xb5, 0x5a,
902	0x67, 0xd9, 0x51, 0x34, 0x3b, 0x23, 0x9a, 0x9d, 0xad, 0xe0, 0xdc, 0x1d, 0x81, 0xec, 0x07, 0x80,
903	0x92, 0xe9, 0x66, 0x21, 0x0d, 0x18, 0x46, 0x8b, 0x30, 0x1f, 0xea, 0x84, 0xd7, 0x5d, 0xf1, 0x69,
904	0xff, 0x6e, 0xc0, 0xc2, 0x53, 0x3c, 0xc0, 0x1c, 0xa7, 0x83, 0xd0, 0x2a, 0xd4, 0xf0, 0x19, 0xe1,
905	0x87, 0x8c, 0x7b, 0x3c, 0x66, 0x92, 0x93, 0xba, 0x0b, 0x62, 0x68, 0x5f, 0x8e, 0xa0, 0x2d, 0xa8,
906	0x0a, 0x0b, 0xfb, 0x87, 0x1e, 0x97, 0xcc, 0xd4, 0x3a, 0x8d, 0x99, 0xf8, 0x0e, 0x46, 0x32, 0xdc,
907	0xae, 0x5c, 0xbc, 0x5b, 0x9d, 0xfb, 0xe3, 0x9f, 0x55, 0xc3, 0xad, 0x28, 0xb7, 0x2d, 0x6e, 0x3b,
908	0xb0, 0xac, 0xe2, 0xd8, 0x8b, 0x68, 0x17, 0x33, 0x96, 0x21, 0x11, 0xfb, 0x4f, 0x03, 0xd0, 0xb3,
909	0x33, 0xdc, 0xcd, 0x07, 0x9f, 0xa0, 0xdb, 0x4c, 0xa3, 0x7b, 0xfe, 0x7a, 0xba, 0x0b, 0x29, 0x74,
910	0x17, 0x27, 0xe8, 0x5e, 0x83, 0x02, 0x0b, 0x71, 0x57, 0x6a, 0x26, 0x8d, 0x1e, 0x89, 0xb0, 0xef,
911	0xc2, 0xc7, 0x13, 0x91, 0xab, 0xbc, 0xdb, 0xaf, 0x61, 0xd1, 0xc5, 0x8c, 0xfc, 0x8a, 0xf7, 0xf8,
912	0x79, 0xd6, 0x71, 0x96, 0xa1, 0xf8, 0x0b, 0xf1, 0x79, 0x5f, 0x73, 0xa1, 0x0c, 0x11, 0x5a, 0x1f,
913	0x93, 0x5e, 0x5f, 0x71, 0x50, 0x77, 0xb5, 0x65, 0x3f, 0x80, 0x3b, 0x82, 0x28, 0x9c, 0x95, 0xd3,
914	0xb7, 0x26, 0xd4, 0x35, 0x50, 0x6b, 0xe1, 0xa6, 0x17, 0x54, 0x6b, 0x67, 0x7e, 0xac, 0x9d, 0x0d,
915	0x91, 0x2e, 0x29, 0x1b, 0x91, 0xc6, 0x85, 0xce, 0xfd, 0xe4, 0xc5, 0x3c, 0x5d, 0xd7, 0x77, 0x53,
916	0xe9, 0xc8, 0xd5, 0xd0, 0x31, 0x23, 0xc5, 0xeb, 0x19, 0x29, 0xa5, 0x30, 0x52, 0x9e, 0x60, 0x24,
917	0xc9, 0x79, 0x65, 0x8a, 0xf3, 0x29, 0x49, 0x57, 0x3f, 0x2c, 0x69, 0xb8, 0x95, 0xa4, 0x5f, 0x40,
918	0xed, 0x3b, 0x32, 0x18, 0xe4, 0x28, 0x76, 0x8c, 0xf4, 0x46, 0xc2, 0xac, 0xbb, 0xda, 0x12, 0xb9,
919	0xf4, 0x06, 0x03, 0x99, 0xcb, 0x8a, 0x2b, 0x3e, 0xed, 0x4d, 0x58, 0xd8, 0x19, 0x50, 0x86, 0x77,
920	0x5f, 0xe4, 0xd0, 0x87, 0x4a, 0xa0, 0xd2, 0xba, 0x32, 0xec, 0xcf, 0xe0, 0xa3, 0xef, 0x09, 0xe3,
921	0x7b, 0xc4, 0xcf, 0xbc, 0x5e, 0x2e, 0x2c, 0x8e, 0xa1, 0x5a, 0x0c, 0x9b, 0x50, 0x0d, 0x95, 0x66,
922	0x31, 0xb3, 0x0c, 0x59, 0x66, 0x5b, 0xd7, 0xb2, 0xa9, 0x95, 0xbd, 0x1b, 0x1c, 0x53, 0x77, 0xec,
923	0x62, 0xff, 0x04, 0x77, 0xc7, 0x15, 0x2d, 0xd9, 0x06, 0x10, 0x14, 0x42, 0x8f, 0xf7, 0x55, 0x18,
924	0xae, 0xfc, 0x4e, 0x16, 0x3c, 0x33, 0x4f, 0xc1, 0x7b, 0x08, 0x8b, 0xfb, 0x7d, 0x32, 0x94, 0x7b,
925	0x8e, 0x02, 0xbe, 0x07, 0x15, 0xd1, 0x62, 0x0f, 0xc7, 0xe5, 0xac, 0x2c, 0xec, 0x3d, 0xe2, 0xdb,
926	0xdf, 0xc2, 0xd2, 0xcb, 0xd0, 0x9f, 0x6a, 0x47, 0x1d, 0xa8, 0x46, 0x98, 0xd1, 0x38, 0xea, 0xca,
927	0x03, 0xa6, 0xef, 0x3a, 0x86, 0xe9, 0xbb, 0x15, 0xf1, 0xac, 0x84, 0x7e, 0x25, 0xaf, 0x96, 0xc0,
928	0x65, 0x5c, 0x2d, 0x7d, 0x85, 0xcc, 0x71, 0x8d, 0xfe, 0x14, 0x6a, 0xaf, 0x3c, 0x92, 0xb9, 0x43,
929	0x04, 0x77, 0x14, 0x4c, 0x6f, 0x30, 0x25, 0x71, 0xe3, 0xc3, 0x12, 0x37, 0x6f, 0x23, 0xf1, 0xce,
930	0xdb, 0x1a, 0x14, 0x44, 0xda, 0x51, 0x1f, 0x8a, 0xb2, 0x72, 0x20, 0xc7, 0xc9, 0x7a, 0xee, 0x38,
931	0xc9, 0x5a, 0xd4, 0x68, 0xe7, 0xc6, 0xeb, 0x63, 0x31, 0x28, 0xa9, 0xce, 0x86, 0x36, 0xb2, 0x5d,
932	0x67, 0x9e, 0x1c, 0x8d, 0x2f, 0x6f, 0xe6, 0xa4, 0x37, 0x55, 0xc7, 0x8b, 0x78, 0xce, 0xe3, 0x5d,
933	0xc9, 0x21, 0xe7, 0xf1, 0x12, 0xb2, 0x70, 0xa1, 0xa4, 0xfa, 0x20, 0x5a, 0x99, 0xe1, 0xe2, 0x99,
934	0x78, 0xfb, 0x35, 0xbe, 0xc8, 0x5e, 0x72, 0xaa, 0xa3, 0x9f, 0x43, 0x7d, 0xa2, 0xb7, 0xa2, 0x47,
935	0x79, 0x97, 0x98, 0xec, 0xae, 0xb7, 0xd8, 0xfa, 0x0d, 0x54, 0x46, 0x75, 0x04, 0xad, 0x67, 0x7b,
936	0x4f, 0x95, 0xa7, 0x46, 0xe7, 0x26, 0x2e, 0x7a, 0xcb, 0xc7, 0x50, 0xdc, 0xf3, 0x62, 0x96, 0x9e,
937	0xc0, 0x94, 0x71, 0xf4, 0x04, 0x4a, 0x2e, 0x66, 0xf1, 0xf0, 0xe6, 0x9e, 0x3f, 0x03, 0x24, 0xde,
938	0x6a, 0x8f, 0x73, 0x48, 0xec, 0xba, 0x3a, 0x98, 0xba, 0xfc, 0x73, 0x28, 0x88, 0x46, 0x82, 0x1e,
939	0x66, 0x2f, 0x9c, 0x68, 0x38, 0xa9, 0xcb, 0x1d, 0x40, 0x41, 0xbc, 0x3f, 0x50, 0x8e, 0xab, 0x30,
940	0xfb, 0xc2, 0x4a, 0x5d, 0xf5, 0x15, 0x54, 0xaf, 0x9e, 0x2f, 0x28, 0x07, 0x6f, 0xd3, 0x6f, 0x9d,
941	0xd4, 0x85, 0xf7, 0xa1, 0xac, 0xbb, 0x1e, 0xca, 0xa1, 0xbf, 0xc9, 0x06, 0x99, 0xba, 0xe8, 0x0f,
942	0x50, 0x19, 0xb5, 0x8b, 0x54, 0xb6, 0x73, 0x1c, 0x62, 0xa6, 0xe5, 0xbc, 0x84, 0x92, 0xea, 0x2b,
943	0x79, 0xaa, 0xd3, 0x4c, 0x07, 0x4a, 0x0d, 0x17, 0x43, 0x41, 0xd4, 0xf6, 0x3c, 0x0a, 0x48, 0xb4,
944	0x8a, 0x86, 0x93, 0x17, 0xae, 0xa2, 0xdf, 0x76, 0x2f, 0xde, 0x37, 0xe7, 0xfe, 0x7e, 0xdf, 0x9c,
945	0xfb, 0xed, 0xb2, 0x69, 0x5c, 0x5c, 0x36, 0x8d, 0xbf, 0x2e, 0x9b, 0xc6, 0xbf, 0x97, 0x4d, 0xe3,
946	0xc7, 0x27, 0xb7, 0xf8, 0x27, 0xf8, 0x1b, 0xf1, 0xfb, 0xda, 0x3c, 0x2a, 0xc9, 0xc3, 0x6c, 0xfc,
947	0x1f, 0x00, 0x00, 0xff, 0xff, 0x64, 0x52, 0x86, 0xc0, 0x49, 0x0f, 0x00, 0x00,
948}
949
950func (m *CreateTaskRequest) Marshal() (dAtA []byte, err error) {
951	size := m.Size()
952	dAtA = make([]byte, size)
953	n, err := m.MarshalToSizedBuffer(dAtA[:size])
954	if err != nil {
955		return nil, err
956	}
957	return dAtA[:n], nil
958}
959
960func (m *CreateTaskRequest) MarshalTo(dAtA []byte) (int, error) {
961	size := m.Size()
962	return m.MarshalToSizedBuffer(dAtA[:size])
963}
964
965func (m *CreateTaskRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
966	i := len(dAtA)
967	_ = i
968	var l int
969	_ = l
970	if m.XXX_unrecognized != nil {
971		i -= len(m.XXX_unrecognized)
972		copy(dAtA[i:], m.XXX_unrecognized)
973	}
974	if m.Options != nil {
975		{
976			size, err := m.Options.MarshalToSizedBuffer(dAtA[:i])
977			if err != nil {
978				return 0, err
979			}
980			i -= size
981			i = encodeVarintShim(dAtA, i, uint64(size))
982		}
983		i--
984		dAtA[i] = 0x5a
985	}
986	if len(m.ParentCheckpoint) > 0 {
987		i -= len(m.ParentCheckpoint)
988		copy(dAtA[i:], m.ParentCheckpoint)
989		i = encodeVarintShim(dAtA, i, uint64(len(m.ParentCheckpoint)))
990		i--
991		dAtA[i] = 0x52
992	}
993	if len(m.Checkpoint) > 0 {
994		i -= len(m.Checkpoint)
995		copy(dAtA[i:], m.Checkpoint)
996		i = encodeVarintShim(dAtA, i, uint64(len(m.Checkpoint)))
997		i--
998		dAtA[i] = 0x4a
999	}
1000	if len(m.Stderr) > 0 {
1001		i -= len(m.Stderr)
1002		copy(dAtA[i:], m.Stderr)
1003		i = encodeVarintShim(dAtA, i, uint64(len(m.Stderr)))
1004		i--
1005		dAtA[i] = 0x42
1006	}
1007	if len(m.Stdout) > 0 {
1008		i -= len(m.Stdout)
1009		copy(dAtA[i:], m.Stdout)
1010		i = encodeVarintShim(dAtA, i, uint64(len(m.Stdout)))
1011		i--
1012		dAtA[i] = 0x3a
1013	}
1014	if len(m.Stdin) > 0 {
1015		i -= len(m.Stdin)
1016		copy(dAtA[i:], m.Stdin)
1017		i = encodeVarintShim(dAtA, i, uint64(len(m.Stdin)))
1018		i--
1019		dAtA[i] = 0x32
1020	}
1021	if m.Terminal {
1022		i--
1023		if m.Terminal {
1024			dAtA[i] = 1
1025		} else {
1026			dAtA[i] = 0
1027		}
1028		i--
1029		dAtA[i] = 0x28
1030	}
1031	if len(m.Rootfs) > 0 {
1032		for iNdEx := len(m.Rootfs) - 1; iNdEx >= 0; iNdEx-- {
1033			{
1034				size, err := m.Rootfs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1035				if err != nil {
1036					return 0, err
1037				}
1038				i -= size
1039				i = encodeVarintShim(dAtA, i, uint64(size))
1040			}
1041			i--
1042			dAtA[i] = 0x22
1043		}
1044	}
1045	if len(m.Runtime) > 0 {
1046		i -= len(m.Runtime)
1047		copy(dAtA[i:], m.Runtime)
1048		i = encodeVarintShim(dAtA, i, uint64(len(m.Runtime)))
1049		i--
1050		dAtA[i] = 0x1a
1051	}
1052	if len(m.Bundle) > 0 {
1053		i -= len(m.Bundle)
1054		copy(dAtA[i:], m.Bundle)
1055		i = encodeVarintShim(dAtA, i, uint64(len(m.Bundle)))
1056		i--
1057		dAtA[i] = 0x12
1058	}
1059	if len(m.ID) > 0 {
1060		i -= len(m.ID)
1061		copy(dAtA[i:], m.ID)
1062		i = encodeVarintShim(dAtA, i, uint64(len(m.ID)))
1063		i--
1064		dAtA[i] = 0xa
1065	}
1066	return len(dAtA) - i, nil
1067}
1068
1069func (m *CreateTaskResponse) Marshal() (dAtA []byte, err error) {
1070	size := m.Size()
1071	dAtA = make([]byte, size)
1072	n, err := m.MarshalToSizedBuffer(dAtA[:size])
1073	if err != nil {
1074		return nil, err
1075	}
1076	return dAtA[:n], nil
1077}
1078
1079func (m *CreateTaskResponse) MarshalTo(dAtA []byte) (int, error) {
1080	size := m.Size()
1081	return m.MarshalToSizedBuffer(dAtA[:size])
1082}
1083
1084func (m *CreateTaskResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1085	i := len(dAtA)
1086	_ = i
1087	var l int
1088	_ = l
1089	if m.XXX_unrecognized != nil {
1090		i -= len(m.XXX_unrecognized)
1091		copy(dAtA[i:], m.XXX_unrecognized)
1092	}
1093	if m.Pid != 0 {
1094		i = encodeVarintShim(dAtA, i, uint64(m.Pid))
1095		i--
1096		dAtA[i] = 0x8
1097	}
1098	return len(dAtA) - i, nil
1099}
1100
1101func (m *DeleteResponse) Marshal() (dAtA []byte, err error) {
1102	size := m.Size()
1103	dAtA = make([]byte, size)
1104	n, err := m.MarshalToSizedBuffer(dAtA[:size])
1105	if err != nil {
1106		return nil, err
1107	}
1108	return dAtA[:n], nil
1109}
1110
1111func (m *DeleteResponse) MarshalTo(dAtA []byte) (int, error) {
1112	size := m.Size()
1113	return m.MarshalToSizedBuffer(dAtA[:size])
1114}
1115
1116func (m *DeleteResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1117	i := len(dAtA)
1118	_ = i
1119	var l int
1120	_ = l
1121	if m.XXX_unrecognized != nil {
1122		i -= len(m.XXX_unrecognized)
1123		copy(dAtA[i:], m.XXX_unrecognized)
1124	}
1125	n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ExitedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.ExitedAt):])
1126	if err2 != nil {
1127		return 0, err2
1128	}
1129	i -= n2
1130	i = encodeVarintShim(dAtA, i, uint64(n2))
1131	i--
1132	dAtA[i] = 0x1a
1133	if m.ExitStatus != 0 {
1134		i = encodeVarintShim(dAtA, i, uint64(m.ExitStatus))
1135		i--
1136		dAtA[i] = 0x10
1137	}
1138	if m.Pid != 0 {
1139		i = encodeVarintShim(dAtA, i, uint64(m.Pid))
1140		i--
1141		dAtA[i] = 0x8
1142	}
1143	return len(dAtA) - i, nil
1144}
1145
1146func (m *DeleteProcessRequest) Marshal() (dAtA []byte, err error) {
1147	size := m.Size()
1148	dAtA = make([]byte, size)
1149	n, err := m.MarshalToSizedBuffer(dAtA[:size])
1150	if err != nil {
1151		return nil, err
1152	}
1153	return dAtA[:n], nil
1154}
1155
1156func (m *DeleteProcessRequest) MarshalTo(dAtA []byte) (int, error) {
1157	size := m.Size()
1158	return m.MarshalToSizedBuffer(dAtA[:size])
1159}
1160
1161func (m *DeleteProcessRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1162	i := len(dAtA)
1163	_ = i
1164	var l int
1165	_ = l
1166	if m.XXX_unrecognized != nil {
1167		i -= len(m.XXX_unrecognized)
1168		copy(dAtA[i:], m.XXX_unrecognized)
1169	}
1170	if len(m.ID) > 0 {
1171		i -= len(m.ID)
1172		copy(dAtA[i:], m.ID)
1173		i = encodeVarintShim(dAtA, i, uint64(len(m.ID)))
1174		i--
1175		dAtA[i] = 0xa
1176	}
1177	return len(dAtA) - i, nil
1178}
1179
1180func (m *ExecProcessRequest) Marshal() (dAtA []byte, err error) {
1181	size := m.Size()
1182	dAtA = make([]byte, size)
1183	n, err := m.MarshalToSizedBuffer(dAtA[:size])
1184	if err != nil {
1185		return nil, err
1186	}
1187	return dAtA[:n], nil
1188}
1189
1190func (m *ExecProcessRequest) MarshalTo(dAtA []byte) (int, error) {
1191	size := m.Size()
1192	return m.MarshalToSizedBuffer(dAtA[:size])
1193}
1194
1195func (m *ExecProcessRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1196	i := len(dAtA)
1197	_ = i
1198	var l int
1199	_ = l
1200	if m.XXX_unrecognized != nil {
1201		i -= len(m.XXX_unrecognized)
1202		copy(dAtA[i:], m.XXX_unrecognized)
1203	}
1204	if m.Spec != nil {
1205		{
1206			size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
1207			if err != nil {
1208				return 0, err
1209			}
1210			i -= size
1211			i = encodeVarintShim(dAtA, i, uint64(size))
1212		}
1213		i--
1214		dAtA[i] = 0x32
1215	}
1216	if len(m.Stderr) > 0 {
1217		i -= len(m.Stderr)
1218		copy(dAtA[i:], m.Stderr)
1219		i = encodeVarintShim(dAtA, i, uint64(len(m.Stderr)))
1220		i--
1221		dAtA[i] = 0x2a
1222	}
1223	if len(m.Stdout) > 0 {
1224		i -= len(m.Stdout)
1225		copy(dAtA[i:], m.Stdout)
1226		i = encodeVarintShim(dAtA, i, uint64(len(m.Stdout)))
1227		i--
1228		dAtA[i] = 0x22
1229	}
1230	if len(m.Stdin) > 0 {
1231		i -= len(m.Stdin)
1232		copy(dAtA[i:], m.Stdin)
1233		i = encodeVarintShim(dAtA, i, uint64(len(m.Stdin)))
1234		i--
1235		dAtA[i] = 0x1a
1236	}
1237	if m.Terminal {
1238		i--
1239		if m.Terminal {
1240			dAtA[i] = 1
1241		} else {
1242			dAtA[i] = 0
1243		}
1244		i--
1245		dAtA[i] = 0x10
1246	}
1247	if len(m.ID) > 0 {
1248		i -= len(m.ID)
1249		copy(dAtA[i:], m.ID)
1250		i = encodeVarintShim(dAtA, i, uint64(len(m.ID)))
1251		i--
1252		dAtA[i] = 0xa
1253	}
1254	return len(dAtA) - i, nil
1255}
1256
1257func (m *ExecProcessResponse) Marshal() (dAtA []byte, err error) {
1258	size := m.Size()
1259	dAtA = make([]byte, size)
1260	n, err := m.MarshalToSizedBuffer(dAtA[:size])
1261	if err != nil {
1262		return nil, err
1263	}
1264	return dAtA[:n], nil
1265}
1266
1267func (m *ExecProcessResponse) MarshalTo(dAtA []byte) (int, error) {
1268	size := m.Size()
1269	return m.MarshalToSizedBuffer(dAtA[:size])
1270}
1271
1272func (m *ExecProcessResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1273	i := len(dAtA)
1274	_ = i
1275	var l int
1276	_ = l
1277	if m.XXX_unrecognized != nil {
1278		i -= len(m.XXX_unrecognized)
1279		copy(dAtA[i:], m.XXX_unrecognized)
1280	}
1281	return len(dAtA) - i, nil
1282}
1283
1284func (m *ResizePtyRequest) Marshal() (dAtA []byte, err error) {
1285	size := m.Size()
1286	dAtA = make([]byte, size)
1287	n, err := m.MarshalToSizedBuffer(dAtA[:size])
1288	if err != nil {
1289		return nil, err
1290	}
1291	return dAtA[:n], nil
1292}
1293
1294func (m *ResizePtyRequest) MarshalTo(dAtA []byte) (int, error) {
1295	size := m.Size()
1296	return m.MarshalToSizedBuffer(dAtA[:size])
1297}
1298
1299func (m *ResizePtyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1300	i := len(dAtA)
1301	_ = i
1302	var l int
1303	_ = l
1304	if m.XXX_unrecognized != nil {
1305		i -= len(m.XXX_unrecognized)
1306		copy(dAtA[i:], m.XXX_unrecognized)
1307	}
1308	if m.Height != 0 {
1309		i = encodeVarintShim(dAtA, i, uint64(m.Height))
1310		i--
1311		dAtA[i] = 0x18
1312	}
1313	if m.Width != 0 {
1314		i = encodeVarintShim(dAtA, i, uint64(m.Width))
1315		i--
1316		dAtA[i] = 0x10
1317	}
1318	if len(m.ID) > 0 {
1319		i -= len(m.ID)
1320		copy(dAtA[i:], m.ID)
1321		i = encodeVarintShim(dAtA, i, uint64(len(m.ID)))
1322		i--
1323		dAtA[i] = 0xa
1324	}
1325	return len(dAtA) - i, nil
1326}
1327
1328func (m *StateRequest) Marshal() (dAtA []byte, err error) {
1329	size := m.Size()
1330	dAtA = make([]byte, size)
1331	n, err := m.MarshalToSizedBuffer(dAtA[:size])
1332	if err != nil {
1333		return nil, err
1334	}
1335	return dAtA[:n], nil
1336}
1337
1338func (m *StateRequest) MarshalTo(dAtA []byte) (int, error) {
1339	size := m.Size()
1340	return m.MarshalToSizedBuffer(dAtA[:size])
1341}
1342
1343func (m *StateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1344	i := len(dAtA)
1345	_ = i
1346	var l int
1347	_ = l
1348	if m.XXX_unrecognized != nil {
1349		i -= len(m.XXX_unrecognized)
1350		copy(dAtA[i:], m.XXX_unrecognized)
1351	}
1352	if len(m.ID) > 0 {
1353		i -= len(m.ID)
1354		copy(dAtA[i:], m.ID)
1355		i = encodeVarintShim(dAtA, i, uint64(len(m.ID)))
1356		i--
1357		dAtA[i] = 0xa
1358	}
1359	return len(dAtA) - i, nil
1360}
1361
1362func (m *StateResponse) Marshal() (dAtA []byte, err error) {
1363	size := m.Size()
1364	dAtA = make([]byte, size)
1365	n, err := m.MarshalToSizedBuffer(dAtA[:size])
1366	if err != nil {
1367		return nil, err
1368	}
1369	return dAtA[:n], nil
1370}
1371
1372func (m *StateResponse) MarshalTo(dAtA []byte) (int, error) {
1373	size := m.Size()
1374	return m.MarshalToSizedBuffer(dAtA[:size])
1375}
1376
1377func (m *StateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1378	i := len(dAtA)
1379	_ = i
1380	var l int
1381	_ = l
1382	if m.XXX_unrecognized != nil {
1383		i -= len(m.XXX_unrecognized)
1384		copy(dAtA[i:], m.XXX_unrecognized)
1385	}
1386	n4, err4 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ExitedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.ExitedAt):])
1387	if err4 != nil {
1388		return 0, err4
1389	}
1390	i -= n4
1391	i = encodeVarintShim(dAtA, i, uint64(n4))
1392	i--
1393	dAtA[i] = 0x52
1394	if m.ExitStatus != 0 {
1395		i = encodeVarintShim(dAtA, i, uint64(m.ExitStatus))
1396		i--
1397		dAtA[i] = 0x48
1398	}
1399	if m.Terminal {
1400		i--
1401		if m.Terminal {
1402			dAtA[i] = 1
1403		} else {
1404			dAtA[i] = 0
1405		}
1406		i--
1407		dAtA[i] = 0x40
1408	}
1409	if len(m.Stderr) > 0 {
1410		i -= len(m.Stderr)
1411		copy(dAtA[i:], m.Stderr)
1412		i = encodeVarintShim(dAtA, i, uint64(len(m.Stderr)))
1413		i--
1414		dAtA[i] = 0x3a
1415	}
1416	if len(m.Stdout) > 0 {
1417		i -= len(m.Stdout)
1418		copy(dAtA[i:], m.Stdout)
1419		i = encodeVarintShim(dAtA, i, uint64(len(m.Stdout)))
1420		i--
1421		dAtA[i] = 0x32
1422	}
1423	if len(m.Stdin) > 0 {
1424		i -= len(m.Stdin)
1425		copy(dAtA[i:], m.Stdin)
1426		i = encodeVarintShim(dAtA, i, uint64(len(m.Stdin)))
1427		i--
1428		dAtA[i] = 0x2a
1429	}
1430	if m.Status != 0 {
1431		i = encodeVarintShim(dAtA, i, uint64(m.Status))
1432		i--
1433		dAtA[i] = 0x20
1434	}
1435	if m.Pid != 0 {
1436		i = encodeVarintShim(dAtA, i, uint64(m.Pid))
1437		i--
1438		dAtA[i] = 0x18
1439	}
1440	if len(m.Bundle) > 0 {
1441		i -= len(m.Bundle)
1442		copy(dAtA[i:], m.Bundle)
1443		i = encodeVarintShim(dAtA, i, uint64(len(m.Bundle)))
1444		i--
1445		dAtA[i] = 0x12
1446	}
1447	if len(m.ID) > 0 {
1448		i -= len(m.ID)
1449		copy(dAtA[i:], m.ID)
1450		i = encodeVarintShim(dAtA, i, uint64(len(m.ID)))
1451		i--
1452		dAtA[i] = 0xa
1453	}
1454	return len(dAtA) - i, nil
1455}
1456
1457func (m *KillRequest) Marshal() (dAtA []byte, err error) {
1458	size := m.Size()
1459	dAtA = make([]byte, size)
1460	n, err := m.MarshalToSizedBuffer(dAtA[:size])
1461	if err != nil {
1462		return nil, err
1463	}
1464	return dAtA[:n], nil
1465}
1466
1467func (m *KillRequest) MarshalTo(dAtA []byte) (int, error) {
1468	size := m.Size()
1469	return m.MarshalToSizedBuffer(dAtA[:size])
1470}
1471
1472func (m *KillRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1473	i := len(dAtA)
1474	_ = i
1475	var l int
1476	_ = l
1477	if m.XXX_unrecognized != nil {
1478		i -= len(m.XXX_unrecognized)
1479		copy(dAtA[i:], m.XXX_unrecognized)
1480	}
1481	if m.All {
1482		i--
1483		if m.All {
1484			dAtA[i] = 1
1485		} else {
1486			dAtA[i] = 0
1487		}
1488		i--
1489		dAtA[i] = 0x18
1490	}
1491	if m.Signal != 0 {
1492		i = encodeVarintShim(dAtA, i, uint64(m.Signal))
1493		i--
1494		dAtA[i] = 0x10
1495	}
1496	if len(m.ID) > 0 {
1497		i -= len(m.ID)
1498		copy(dAtA[i:], m.ID)
1499		i = encodeVarintShim(dAtA, i, uint64(len(m.ID)))
1500		i--
1501		dAtA[i] = 0xa
1502	}
1503	return len(dAtA) - i, nil
1504}
1505
1506func (m *CloseIORequest) Marshal() (dAtA []byte, err error) {
1507	size := m.Size()
1508	dAtA = make([]byte, size)
1509	n, err := m.MarshalToSizedBuffer(dAtA[:size])
1510	if err != nil {
1511		return nil, err
1512	}
1513	return dAtA[:n], nil
1514}
1515
1516func (m *CloseIORequest) MarshalTo(dAtA []byte) (int, error) {
1517	size := m.Size()
1518	return m.MarshalToSizedBuffer(dAtA[:size])
1519}
1520
1521func (m *CloseIORequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1522	i := len(dAtA)
1523	_ = i
1524	var l int
1525	_ = l
1526	if m.XXX_unrecognized != nil {
1527		i -= len(m.XXX_unrecognized)
1528		copy(dAtA[i:], m.XXX_unrecognized)
1529	}
1530	if m.Stdin {
1531		i--
1532		if m.Stdin {
1533			dAtA[i] = 1
1534		} else {
1535			dAtA[i] = 0
1536		}
1537		i--
1538		dAtA[i] = 0x10
1539	}
1540	if len(m.ID) > 0 {
1541		i -= len(m.ID)
1542		copy(dAtA[i:], m.ID)
1543		i = encodeVarintShim(dAtA, i, uint64(len(m.ID)))
1544		i--
1545		dAtA[i] = 0xa
1546	}
1547	return len(dAtA) - i, nil
1548}
1549
1550func (m *ListPidsRequest) Marshal() (dAtA []byte, err error) {
1551	size := m.Size()
1552	dAtA = make([]byte, size)
1553	n, err := m.MarshalToSizedBuffer(dAtA[:size])
1554	if err != nil {
1555		return nil, err
1556	}
1557	return dAtA[:n], nil
1558}
1559
1560func (m *ListPidsRequest) MarshalTo(dAtA []byte) (int, error) {
1561	size := m.Size()
1562	return m.MarshalToSizedBuffer(dAtA[:size])
1563}
1564
1565func (m *ListPidsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1566	i := len(dAtA)
1567	_ = i
1568	var l int
1569	_ = l
1570	if m.XXX_unrecognized != nil {
1571		i -= len(m.XXX_unrecognized)
1572		copy(dAtA[i:], m.XXX_unrecognized)
1573	}
1574	if len(m.ID) > 0 {
1575		i -= len(m.ID)
1576		copy(dAtA[i:], m.ID)
1577		i = encodeVarintShim(dAtA, i, uint64(len(m.ID)))
1578		i--
1579		dAtA[i] = 0xa
1580	}
1581	return len(dAtA) - i, nil
1582}
1583
1584func (m *ListPidsResponse) Marshal() (dAtA []byte, err error) {
1585	size := m.Size()
1586	dAtA = make([]byte, size)
1587	n, err := m.MarshalToSizedBuffer(dAtA[:size])
1588	if err != nil {
1589		return nil, err
1590	}
1591	return dAtA[:n], nil
1592}
1593
1594func (m *ListPidsResponse) MarshalTo(dAtA []byte) (int, error) {
1595	size := m.Size()
1596	return m.MarshalToSizedBuffer(dAtA[:size])
1597}
1598
1599func (m *ListPidsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1600	i := len(dAtA)
1601	_ = i
1602	var l int
1603	_ = l
1604	if m.XXX_unrecognized != nil {
1605		i -= len(m.XXX_unrecognized)
1606		copy(dAtA[i:], m.XXX_unrecognized)
1607	}
1608	if len(m.Processes) > 0 {
1609		for iNdEx := len(m.Processes) - 1; iNdEx >= 0; iNdEx-- {
1610			{
1611				size, err := m.Processes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1612				if err != nil {
1613					return 0, err
1614				}
1615				i -= size
1616				i = encodeVarintShim(dAtA, i, uint64(size))
1617			}
1618			i--
1619			dAtA[i] = 0xa
1620		}
1621	}
1622	return len(dAtA) - i, nil
1623}
1624
1625func (m *CheckpointTaskRequest) Marshal() (dAtA []byte, err error) {
1626	size := m.Size()
1627	dAtA = make([]byte, size)
1628	n, err := m.MarshalToSizedBuffer(dAtA[:size])
1629	if err != nil {
1630		return nil, err
1631	}
1632	return dAtA[:n], nil
1633}
1634
1635func (m *CheckpointTaskRequest) MarshalTo(dAtA []byte) (int, error) {
1636	size := m.Size()
1637	return m.MarshalToSizedBuffer(dAtA[:size])
1638}
1639
1640func (m *CheckpointTaskRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1641	i := len(dAtA)
1642	_ = i
1643	var l int
1644	_ = l
1645	if m.XXX_unrecognized != nil {
1646		i -= len(m.XXX_unrecognized)
1647		copy(dAtA[i:], m.XXX_unrecognized)
1648	}
1649	if m.Options != nil {
1650		{
1651			size, err := m.Options.MarshalToSizedBuffer(dAtA[:i])
1652			if err != nil {
1653				return 0, err
1654			}
1655			i -= size
1656			i = encodeVarintShim(dAtA, i, uint64(size))
1657		}
1658		i--
1659		dAtA[i] = 0x12
1660	}
1661	if len(m.Path) > 0 {
1662		i -= len(m.Path)
1663		copy(dAtA[i:], m.Path)
1664		i = encodeVarintShim(dAtA, i, uint64(len(m.Path)))
1665		i--
1666		dAtA[i] = 0xa
1667	}
1668	return len(dAtA) - i, nil
1669}
1670
1671func (m *ShimInfoResponse) Marshal() (dAtA []byte, err error) {
1672	size := m.Size()
1673	dAtA = make([]byte, size)
1674	n, err := m.MarshalToSizedBuffer(dAtA[:size])
1675	if err != nil {
1676		return nil, err
1677	}
1678	return dAtA[:n], nil
1679}
1680
1681func (m *ShimInfoResponse) MarshalTo(dAtA []byte) (int, error) {
1682	size := m.Size()
1683	return m.MarshalToSizedBuffer(dAtA[:size])
1684}
1685
1686func (m *ShimInfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1687	i := len(dAtA)
1688	_ = i
1689	var l int
1690	_ = l
1691	if m.XXX_unrecognized != nil {
1692		i -= len(m.XXX_unrecognized)
1693		copy(dAtA[i:], m.XXX_unrecognized)
1694	}
1695	if m.ShimPid != 0 {
1696		i = encodeVarintShim(dAtA, i, uint64(m.ShimPid))
1697		i--
1698		dAtA[i] = 0x8
1699	}
1700	return len(dAtA) - i, nil
1701}
1702
1703func (m *UpdateTaskRequest) Marshal() (dAtA []byte, err error) {
1704	size := m.Size()
1705	dAtA = make([]byte, size)
1706	n, err := m.MarshalToSizedBuffer(dAtA[:size])
1707	if err != nil {
1708		return nil, err
1709	}
1710	return dAtA[:n], nil
1711}
1712
1713func (m *UpdateTaskRequest) MarshalTo(dAtA []byte) (int, error) {
1714	size := m.Size()
1715	return m.MarshalToSizedBuffer(dAtA[:size])
1716}
1717
1718func (m *UpdateTaskRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1719	i := len(dAtA)
1720	_ = i
1721	var l int
1722	_ = l
1723	if m.XXX_unrecognized != nil {
1724		i -= len(m.XXX_unrecognized)
1725		copy(dAtA[i:], m.XXX_unrecognized)
1726	}
1727	if m.Resources != nil {
1728		{
1729			size, err := m.Resources.MarshalToSizedBuffer(dAtA[:i])
1730			if err != nil {
1731				return 0, err
1732			}
1733			i -= size
1734			i = encodeVarintShim(dAtA, i, uint64(size))
1735		}
1736		i--
1737		dAtA[i] = 0xa
1738	}
1739	return len(dAtA) - i, nil
1740}
1741
1742func (m *StartRequest) Marshal() (dAtA []byte, err error) {
1743	size := m.Size()
1744	dAtA = make([]byte, size)
1745	n, err := m.MarshalToSizedBuffer(dAtA[:size])
1746	if err != nil {
1747		return nil, err
1748	}
1749	return dAtA[:n], nil
1750}
1751
1752func (m *StartRequest) MarshalTo(dAtA []byte) (int, error) {
1753	size := m.Size()
1754	return m.MarshalToSizedBuffer(dAtA[:size])
1755}
1756
1757func (m *StartRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1758	i := len(dAtA)
1759	_ = i
1760	var l int
1761	_ = l
1762	if m.XXX_unrecognized != nil {
1763		i -= len(m.XXX_unrecognized)
1764		copy(dAtA[i:], m.XXX_unrecognized)
1765	}
1766	if len(m.ID) > 0 {
1767		i -= len(m.ID)
1768		copy(dAtA[i:], m.ID)
1769		i = encodeVarintShim(dAtA, i, uint64(len(m.ID)))
1770		i--
1771		dAtA[i] = 0xa
1772	}
1773	return len(dAtA) - i, nil
1774}
1775
1776func (m *StartResponse) Marshal() (dAtA []byte, err error) {
1777	size := m.Size()
1778	dAtA = make([]byte, size)
1779	n, err := m.MarshalToSizedBuffer(dAtA[:size])
1780	if err != nil {
1781		return nil, err
1782	}
1783	return dAtA[:n], nil
1784}
1785
1786func (m *StartResponse) MarshalTo(dAtA []byte) (int, error) {
1787	size := m.Size()
1788	return m.MarshalToSizedBuffer(dAtA[:size])
1789}
1790
1791func (m *StartResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1792	i := len(dAtA)
1793	_ = i
1794	var l int
1795	_ = l
1796	if m.XXX_unrecognized != nil {
1797		i -= len(m.XXX_unrecognized)
1798		copy(dAtA[i:], m.XXX_unrecognized)
1799	}
1800	if m.Pid != 0 {
1801		i = encodeVarintShim(dAtA, i, uint64(m.Pid))
1802		i--
1803		dAtA[i] = 0x10
1804	}
1805	if len(m.ID) > 0 {
1806		i -= len(m.ID)
1807		copy(dAtA[i:], m.ID)
1808		i = encodeVarintShim(dAtA, i, uint64(len(m.ID)))
1809		i--
1810		dAtA[i] = 0xa
1811	}
1812	return len(dAtA) - i, nil
1813}
1814
1815func (m *WaitRequest) Marshal() (dAtA []byte, err error) {
1816	size := m.Size()
1817	dAtA = make([]byte, size)
1818	n, err := m.MarshalToSizedBuffer(dAtA[:size])
1819	if err != nil {
1820		return nil, err
1821	}
1822	return dAtA[:n], nil
1823}
1824
1825func (m *WaitRequest) MarshalTo(dAtA []byte) (int, error) {
1826	size := m.Size()
1827	return m.MarshalToSizedBuffer(dAtA[:size])
1828}
1829
1830func (m *WaitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1831	i := len(dAtA)
1832	_ = i
1833	var l int
1834	_ = l
1835	if m.XXX_unrecognized != nil {
1836		i -= len(m.XXX_unrecognized)
1837		copy(dAtA[i:], m.XXX_unrecognized)
1838	}
1839	if len(m.ID) > 0 {
1840		i -= len(m.ID)
1841		copy(dAtA[i:], m.ID)
1842		i = encodeVarintShim(dAtA, i, uint64(len(m.ID)))
1843		i--
1844		dAtA[i] = 0xa
1845	}
1846	return len(dAtA) - i, nil
1847}
1848
1849func (m *WaitResponse) Marshal() (dAtA []byte, err error) {
1850	size := m.Size()
1851	dAtA = make([]byte, size)
1852	n, err := m.MarshalToSizedBuffer(dAtA[:size])
1853	if err != nil {
1854		return nil, err
1855	}
1856	return dAtA[:n], nil
1857}
1858
1859func (m *WaitResponse) MarshalTo(dAtA []byte) (int, error) {
1860	size := m.Size()
1861	return m.MarshalToSizedBuffer(dAtA[:size])
1862}
1863
1864func (m *WaitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1865	i := len(dAtA)
1866	_ = i
1867	var l int
1868	_ = l
1869	if m.XXX_unrecognized != nil {
1870		i -= len(m.XXX_unrecognized)
1871		copy(dAtA[i:], m.XXX_unrecognized)
1872	}
1873	n7, err7 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ExitedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.ExitedAt):])
1874	if err7 != nil {
1875		return 0, err7
1876	}
1877	i -= n7
1878	i = encodeVarintShim(dAtA, i, uint64(n7))
1879	i--
1880	dAtA[i] = 0x12
1881	if m.ExitStatus != 0 {
1882		i = encodeVarintShim(dAtA, i, uint64(m.ExitStatus))
1883		i--
1884		dAtA[i] = 0x8
1885	}
1886	return len(dAtA) - i, nil
1887}
1888
1889func encodeVarintShim(dAtA []byte, offset int, v uint64) int {
1890	offset -= sovShim(v)
1891	base := offset
1892	for v >= 1<<7 {
1893		dAtA[offset] = uint8(v&0x7f | 0x80)
1894		v >>= 7
1895		offset++
1896	}
1897	dAtA[offset] = uint8(v)
1898	return base
1899}
1900func (m *CreateTaskRequest) Size() (n int) {
1901	if m == nil {
1902		return 0
1903	}
1904	var l int
1905	_ = l
1906	l = len(m.ID)
1907	if l > 0 {
1908		n += 1 + l + sovShim(uint64(l))
1909	}
1910	l = len(m.Bundle)
1911	if l > 0 {
1912		n += 1 + l + sovShim(uint64(l))
1913	}
1914	l = len(m.Runtime)
1915	if l > 0 {
1916		n += 1 + l + sovShim(uint64(l))
1917	}
1918	if len(m.Rootfs) > 0 {
1919		for _, e := range m.Rootfs {
1920			l = e.Size()
1921			n += 1 + l + sovShim(uint64(l))
1922		}
1923	}
1924	if m.Terminal {
1925		n += 2
1926	}
1927	l = len(m.Stdin)
1928	if l > 0 {
1929		n += 1 + l + sovShim(uint64(l))
1930	}
1931	l = len(m.Stdout)
1932	if l > 0 {
1933		n += 1 + l + sovShim(uint64(l))
1934	}
1935	l = len(m.Stderr)
1936	if l > 0 {
1937		n += 1 + l + sovShim(uint64(l))
1938	}
1939	l = len(m.Checkpoint)
1940	if l > 0 {
1941		n += 1 + l + sovShim(uint64(l))
1942	}
1943	l = len(m.ParentCheckpoint)
1944	if l > 0 {
1945		n += 1 + l + sovShim(uint64(l))
1946	}
1947	if m.Options != nil {
1948		l = m.Options.Size()
1949		n += 1 + l + sovShim(uint64(l))
1950	}
1951	if m.XXX_unrecognized != nil {
1952		n += len(m.XXX_unrecognized)
1953	}
1954	return n
1955}
1956
1957func (m *CreateTaskResponse) Size() (n int) {
1958	if m == nil {
1959		return 0
1960	}
1961	var l int
1962	_ = l
1963	if m.Pid != 0 {
1964		n += 1 + sovShim(uint64(m.Pid))
1965	}
1966	if m.XXX_unrecognized != nil {
1967		n += len(m.XXX_unrecognized)
1968	}
1969	return n
1970}
1971
1972func (m *DeleteResponse) Size() (n int) {
1973	if m == nil {
1974		return 0
1975	}
1976	var l int
1977	_ = l
1978	if m.Pid != 0 {
1979		n += 1 + sovShim(uint64(m.Pid))
1980	}
1981	if m.ExitStatus != 0 {
1982		n += 1 + sovShim(uint64(m.ExitStatus))
1983	}
1984	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.ExitedAt)
1985	n += 1 + l + sovShim(uint64(l))
1986	if m.XXX_unrecognized != nil {
1987		n += len(m.XXX_unrecognized)
1988	}
1989	return n
1990}
1991
1992func (m *DeleteProcessRequest) Size() (n int) {
1993	if m == nil {
1994		return 0
1995	}
1996	var l int
1997	_ = l
1998	l = len(m.ID)
1999	if l > 0 {
2000		n += 1 + l + sovShim(uint64(l))
2001	}
2002	if m.XXX_unrecognized != nil {
2003		n += len(m.XXX_unrecognized)
2004	}
2005	return n
2006}
2007
2008func (m *ExecProcessRequest) Size() (n int) {
2009	if m == nil {
2010		return 0
2011	}
2012	var l int
2013	_ = l
2014	l = len(m.ID)
2015	if l > 0 {
2016		n += 1 + l + sovShim(uint64(l))
2017	}
2018	if m.Terminal {
2019		n += 2
2020	}
2021	l = len(m.Stdin)
2022	if l > 0 {
2023		n += 1 + l + sovShim(uint64(l))
2024	}
2025	l = len(m.Stdout)
2026	if l > 0 {
2027		n += 1 + l + sovShim(uint64(l))
2028	}
2029	l = len(m.Stderr)
2030	if l > 0 {
2031		n += 1 + l + sovShim(uint64(l))
2032	}
2033	if m.Spec != nil {
2034		l = m.Spec.Size()
2035		n += 1 + l + sovShim(uint64(l))
2036	}
2037	if m.XXX_unrecognized != nil {
2038		n += len(m.XXX_unrecognized)
2039	}
2040	return n
2041}
2042
2043func (m *ExecProcessResponse) Size() (n int) {
2044	if m == nil {
2045		return 0
2046	}
2047	var l int
2048	_ = l
2049	if m.XXX_unrecognized != nil {
2050		n += len(m.XXX_unrecognized)
2051	}
2052	return n
2053}
2054
2055func (m *ResizePtyRequest) Size() (n int) {
2056	if m == nil {
2057		return 0
2058	}
2059	var l int
2060	_ = l
2061	l = len(m.ID)
2062	if l > 0 {
2063		n += 1 + l + sovShim(uint64(l))
2064	}
2065	if m.Width != 0 {
2066		n += 1 + sovShim(uint64(m.Width))
2067	}
2068	if m.Height != 0 {
2069		n += 1 + sovShim(uint64(m.Height))
2070	}
2071	if m.XXX_unrecognized != nil {
2072		n += len(m.XXX_unrecognized)
2073	}
2074	return n
2075}
2076
2077func (m *StateRequest) Size() (n int) {
2078	if m == nil {
2079		return 0
2080	}
2081	var l int
2082	_ = l
2083	l = len(m.ID)
2084	if l > 0 {
2085		n += 1 + l + sovShim(uint64(l))
2086	}
2087	if m.XXX_unrecognized != nil {
2088		n += len(m.XXX_unrecognized)
2089	}
2090	return n
2091}
2092
2093func (m *StateResponse) Size() (n int) {
2094	if m == nil {
2095		return 0
2096	}
2097	var l int
2098	_ = l
2099	l = len(m.ID)
2100	if l > 0 {
2101		n += 1 + l + sovShim(uint64(l))
2102	}
2103	l = len(m.Bundle)
2104	if l > 0 {
2105		n += 1 + l + sovShim(uint64(l))
2106	}
2107	if m.Pid != 0 {
2108		n += 1 + sovShim(uint64(m.Pid))
2109	}
2110	if m.Status != 0 {
2111		n += 1 + sovShim(uint64(m.Status))
2112	}
2113	l = len(m.Stdin)
2114	if l > 0 {
2115		n += 1 + l + sovShim(uint64(l))
2116	}
2117	l = len(m.Stdout)
2118	if l > 0 {
2119		n += 1 + l + sovShim(uint64(l))
2120	}
2121	l = len(m.Stderr)
2122	if l > 0 {
2123		n += 1 + l + sovShim(uint64(l))
2124	}
2125	if m.Terminal {
2126		n += 2
2127	}
2128	if m.ExitStatus != 0 {
2129		n += 1 + sovShim(uint64(m.ExitStatus))
2130	}
2131	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.ExitedAt)
2132	n += 1 + l + sovShim(uint64(l))
2133	if m.XXX_unrecognized != nil {
2134		n += len(m.XXX_unrecognized)
2135	}
2136	return n
2137}
2138
2139func (m *KillRequest) Size() (n int) {
2140	if m == nil {
2141		return 0
2142	}
2143	var l int
2144	_ = l
2145	l = len(m.ID)
2146	if l > 0 {
2147		n += 1 + l + sovShim(uint64(l))
2148	}
2149	if m.Signal != 0 {
2150		n += 1 + sovShim(uint64(m.Signal))
2151	}
2152	if m.All {
2153		n += 2
2154	}
2155	if m.XXX_unrecognized != nil {
2156		n += len(m.XXX_unrecognized)
2157	}
2158	return n
2159}
2160
2161func (m *CloseIORequest) Size() (n int) {
2162	if m == nil {
2163		return 0
2164	}
2165	var l int
2166	_ = l
2167	l = len(m.ID)
2168	if l > 0 {
2169		n += 1 + l + sovShim(uint64(l))
2170	}
2171	if m.Stdin {
2172		n += 2
2173	}
2174	if m.XXX_unrecognized != nil {
2175		n += len(m.XXX_unrecognized)
2176	}
2177	return n
2178}
2179
2180func (m *ListPidsRequest) Size() (n int) {
2181	if m == nil {
2182		return 0
2183	}
2184	var l int
2185	_ = l
2186	l = len(m.ID)
2187	if l > 0 {
2188		n += 1 + l + sovShim(uint64(l))
2189	}
2190	if m.XXX_unrecognized != nil {
2191		n += len(m.XXX_unrecognized)
2192	}
2193	return n
2194}
2195
2196func (m *ListPidsResponse) Size() (n int) {
2197	if m == nil {
2198		return 0
2199	}
2200	var l int
2201	_ = l
2202	if len(m.Processes) > 0 {
2203		for _, e := range m.Processes {
2204			l = e.Size()
2205			n += 1 + l + sovShim(uint64(l))
2206		}
2207	}
2208	if m.XXX_unrecognized != nil {
2209		n += len(m.XXX_unrecognized)
2210	}
2211	return n
2212}
2213
2214func (m *CheckpointTaskRequest) Size() (n int) {
2215	if m == nil {
2216		return 0
2217	}
2218	var l int
2219	_ = l
2220	l = len(m.Path)
2221	if l > 0 {
2222		n += 1 + l + sovShim(uint64(l))
2223	}
2224	if m.Options != nil {
2225		l = m.Options.Size()
2226		n += 1 + l + sovShim(uint64(l))
2227	}
2228	if m.XXX_unrecognized != nil {
2229		n += len(m.XXX_unrecognized)
2230	}
2231	return n
2232}
2233
2234func (m *ShimInfoResponse) Size() (n int) {
2235	if m == nil {
2236		return 0
2237	}
2238	var l int
2239	_ = l
2240	if m.ShimPid != 0 {
2241		n += 1 + sovShim(uint64(m.ShimPid))
2242	}
2243	if m.XXX_unrecognized != nil {
2244		n += len(m.XXX_unrecognized)
2245	}
2246	return n
2247}
2248
2249func (m *UpdateTaskRequest) Size() (n int) {
2250	if m == nil {
2251		return 0
2252	}
2253	var l int
2254	_ = l
2255	if m.Resources != nil {
2256		l = m.Resources.Size()
2257		n += 1 + l + sovShim(uint64(l))
2258	}
2259	if m.XXX_unrecognized != nil {
2260		n += len(m.XXX_unrecognized)
2261	}
2262	return n
2263}
2264
2265func (m *StartRequest) Size() (n int) {
2266	if m == nil {
2267		return 0
2268	}
2269	var l int
2270	_ = l
2271	l = len(m.ID)
2272	if l > 0 {
2273		n += 1 + l + sovShim(uint64(l))
2274	}
2275	if m.XXX_unrecognized != nil {
2276		n += len(m.XXX_unrecognized)
2277	}
2278	return n
2279}
2280
2281func (m *StartResponse) Size() (n int) {
2282	if m == nil {
2283		return 0
2284	}
2285	var l int
2286	_ = l
2287	l = len(m.ID)
2288	if l > 0 {
2289		n += 1 + l + sovShim(uint64(l))
2290	}
2291	if m.Pid != 0 {
2292		n += 1 + sovShim(uint64(m.Pid))
2293	}
2294	if m.XXX_unrecognized != nil {
2295		n += len(m.XXX_unrecognized)
2296	}
2297	return n
2298}
2299
2300func (m *WaitRequest) Size() (n int) {
2301	if m == nil {
2302		return 0
2303	}
2304	var l int
2305	_ = l
2306	l = len(m.ID)
2307	if l > 0 {
2308		n += 1 + l + sovShim(uint64(l))
2309	}
2310	if m.XXX_unrecognized != nil {
2311		n += len(m.XXX_unrecognized)
2312	}
2313	return n
2314}
2315
2316func (m *WaitResponse) Size() (n int) {
2317	if m == nil {
2318		return 0
2319	}
2320	var l int
2321	_ = l
2322	if m.ExitStatus != 0 {
2323		n += 1 + sovShim(uint64(m.ExitStatus))
2324	}
2325	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.ExitedAt)
2326	n += 1 + l + sovShim(uint64(l))
2327	if m.XXX_unrecognized != nil {
2328		n += len(m.XXX_unrecognized)
2329	}
2330	return n
2331}
2332
2333func sovShim(x uint64) (n int) {
2334	return (math_bits.Len64(x|1) + 6) / 7
2335}
2336func sozShim(x uint64) (n int) {
2337	return sovShim(uint64((x << 1) ^ uint64((int64(x) >> 63))))
2338}
2339func (this *CreateTaskRequest) String() string {
2340	if this == nil {
2341		return "nil"
2342	}
2343	repeatedStringForRootfs := "[]*Mount{"
2344	for _, f := range this.Rootfs {
2345		repeatedStringForRootfs += strings.Replace(fmt.Sprintf("%v", f), "Mount", "types.Mount", 1) + ","
2346	}
2347	repeatedStringForRootfs += "}"
2348	s := strings.Join([]string{`&CreateTaskRequest{`,
2349		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
2350		`Bundle:` + fmt.Sprintf("%v", this.Bundle) + `,`,
2351		`Runtime:` + fmt.Sprintf("%v", this.Runtime) + `,`,
2352		`Rootfs:` + repeatedStringForRootfs + `,`,
2353		`Terminal:` + fmt.Sprintf("%v", this.Terminal) + `,`,
2354		`Stdin:` + fmt.Sprintf("%v", this.Stdin) + `,`,
2355		`Stdout:` + fmt.Sprintf("%v", this.Stdout) + `,`,
2356		`Stderr:` + fmt.Sprintf("%v", this.Stderr) + `,`,
2357		`Checkpoint:` + fmt.Sprintf("%v", this.Checkpoint) + `,`,
2358		`ParentCheckpoint:` + fmt.Sprintf("%v", this.ParentCheckpoint) + `,`,
2359		`Options:` + strings.Replace(fmt.Sprintf("%v", this.Options), "Any", "types1.Any", 1) + `,`,
2360		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2361		`}`,
2362	}, "")
2363	return s
2364}
2365func (this *CreateTaskResponse) String() string {
2366	if this == nil {
2367		return "nil"
2368	}
2369	s := strings.Join([]string{`&CreateTaskResponse{`,
2370		`Pid:` + fmt.Sprintf("%v", this.Pid) + `,`,
2371		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2372		`}`,
2373	}, "")
2374	return s
2375}
2376func (this *DeleteResponse) String() string {
2377	if this == nil {
2378		return "nil"
2379	}
2380	s := strings.Join([]string{`&DeleteResponse{`,
2381		`Pid:` + fmt.Sprintf("%v", this.Pid) + `,`,
2382		`ExitStatus:` + fmt.Sprintf("%v", this.ExitStatus) + `,`,
2383		`ExitedAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ExitedAt), "Timestamp", "types1.Timestamp", 1), `&`, ``, 1) + `,`,
2384		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2385		`}`,
2386	}, "")
2387	return s
2388}
2389func (this *DeleteProcessRequest) String() string {
2390	if this == nil {
2391		return "nil"
2392	}
2393	s := strings.Join([]string{`&DeleteProcessRequest{`,
2394		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
2395		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2396		`}`,
2397	}, "")
2398	return s
2399}
2400func (this *ExecProcessRequest) String() string {
2401	if this == nil {
2402		return "nil"
2403	}
2404	s := strings.Join([]string{`&ExecProcessRequest{`,
2405		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
2406		`Terminal:` + fmt.Sprintf("%v", this.Terminal) + `,`,
2407		`Stdin:` + fmt.Sprintf("%v", this.Stdin) + `,`,
2408		`Stdout:` + fmt.Sprintf("%v", this.Stdout) + `,`,
2409		`Stderr:` + fmt.Sprintf("%v", this.Stderr) + `,`,
2410		`Spec:` + strings.Replace(fmt.Sprintf("%v", this.Spec), "Any", "types1.Any", 1) + `,`,
2411		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2412		`}`,
2413	}, "")
2414	return s
2415}
2416func (this *ExecProcessResponse) String() string {
2417	if this == nil {
2418		return "nil"
2419	}
2420	s := strings.Join([]string{`&ExecProcessResponse{`,
2421		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2422		`}`,
2423	}, "")
2424	return s
2425}
2426func (this *ResizePtyRequest) String() string {
2427	if this == nil {
2428		return "nil"
2429	}
2430	s := strings.Join([]string{`&ResizePtyRequest{`,
2431		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
2432		`Width:` + fmt.Sprintf("%v", this.Width) + `,`,
2433		`Height:` + fmt.Sprintf("%v", this.Height) + `,`,
2434		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2435		`}`,
2436	}, "")
2437	return s
2438}
2439func (this *StateRequest) String() string {
2440	if this == nil {
2441		return "nil"
2442	}
2443	s := strings.Join([]string{`&StateRequest{`,
2444		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
2445		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2446		`}`,
2447	}, "")
2448	return s
2449}
2450func (this *StateResponse) String() string {
2451	if this == nil {
2452		return "nil"
2453	}
2454	s := strings.Join([]string{`&StateResponse{`,
2455		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
2456		`Bundle:` + fmt.Sprintf("%v", this.Bundle) + `,`,
2457		`Pid:` + fmt.Sprintf("%v", this.Pid) + `,`,
2458		`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
2459		`Stdin:` + fmt.Sprintf("%v", this.Stdin) + `,`,
2460		`Stdout:` + fmt.Sprintf("%v", this.Stdout) + `,`,
2461		`Stderr:` + fmt.Sprintf("%v", this.Stderr) + `,`,
2462		`Terminal:` + fmt.Sprintf("%v", this.Terminal) + `,`,
2463		`ExitStatus:` + fmt.Sprintf("%v", this.ExitStatus) + `,`,
2464		`ExitedAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ExitedAt), "Timestamp", "types1.Timestamp", 1), `&`, ``, 1) + `,`,
2465		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2466		`}`,
2467	}, "")
2468	return s
2469}
2470func (this *KillRequest) String() string {
2471	if this == nil {
2472		return "nil"
2473	}
2474	s := strings.Join([]string{`&KillRequest{`,
2475		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
2476		`Signal:` + fmt.Sprintf("%v", this.Signal) + `,`,
2477		`All:` + fmt.Sprintf("%v", this.All) + `,`,
2478		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2479		`}`,
2480	}, "")
2481	return s
2482}
2483func (this *CloseIORequest) String() string {
2484	if this == nil {
2485		return "nil"
2486	}
2487	s := strings.Join([]string{`&CloseIORequest{`,
2488		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
2489		`Stdin:` + fmt.Sprintf("%v", this.Stdin) + `,`,
2490		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2491		`}`,
2492	}, "")
2493	return s
2494}
2495func (this *ListPidsRequest) String() string {
2496	if this == nil {
2497		return "nil"
2498	}
2499	s := strings.Join([]string{`&ListPidsRequest{`,
2500		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
2501		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2502		`}`,
2503	}, "")
2504	return s
2505}
2506func (this *ListPidsResponse) String() string {
2507	if this == nil {
2508		return "nil"
2509	}
2510	repeatedStringForProcesses := "[]*ProcessInfo{"
2511	for _, f := range this.Processes {
2512		repeatedStringForProcesses += strings.Replace(fmt.Sprintf("%v", f), "ProcessInfo", "task.ProcessInfo", 1) + ","
2513	}
2514	repeatedStringForProcesses += "}"
2515	s := strings.Join([]string{`&ListPidsResponse{`,
2516		`Processes:` + repeatedStringForProcesses + `,`,
2517		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2518		`}`,
2519	}, "")
2520	return s
2521}
2522func (this *CheckpointTaskRequest) String() string {
2523	if this == nil {
2524		return "nil"
2525	}
2526	s := strings.Join([]string{`&CheckpointTaskRequest{`,
2527		`Path:` + fmt.Sprintf("%v", this.Path) + `,`,
2528		`Options:` + strings.Replace(fmt.Sprintf("%v", this.Options), "Any", "types1.Any", 1) + `,`,
2529		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2530		`}`,
2531	}, "")
2532	return s
2533}
2534func (this *ShimInfoResponse) String() string {
2535	if this == nil {
2536		return "nil"
2537	}
2538	s := strings.Join([]string{`&ShimInfoResponse{`,
2539		`ShimPid:` + fmt.Sprintf("%v", this.ShimPid) + `,`,
2540		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2541		`}`,
2542	}, "")
2543	return s
2544}
2545func (this *UpdateTaskRequest) String() string {
2546	if this == nil {
2547		return "nil"
2548	}
2549	s := strings.Join([]string{`&UpdateTaskRequest{`,
2550		`Resources:` + strings.Replace(fmt.Sprintf("%v", this.Resources), "Any", "types1.Any", 1) + `,`,
2551		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2552		`}`,
2553	}, "")
2554	return s
2555}
2556func (this *StartRequest) String() string {
2557	if this == nil {
2558		return "nil"
2559	}
2560	s := strings.Join([]string{`&StartRequest{`,
2561		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
2562		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2563		`}`,
2564	}, "")
2565	return s
2566}
2567func (this *StartResponse) String() string {
2568	if this == nil {
2569		return "nil"
2570	}
2571	s := strings.Join([]string{`&StartResponse{`,
2572		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
2573		`Pid:` + fmt.Sprintf("%v", this.Pid) + `,`,
2574		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2575		`}`,
2576	}, "")
2577	return s
2578}
2579func (this *WaitRequest) String() string {
2580	if this == nil {
2581		return "nil"
2582	}
2583	s := strings.Join([]string{`&WaitRequest{`,
2584		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
2585		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2586		`}`,
2587	}, "")
2588	return s
2589}
2590func (this *WaitResponse) String() string {
2591	if this == nil {
2592		return "nil"
2593	}
2594	s := strings.Join([]string{`&WaitResponse{`,
2595		`ExitStatus:` + fmt.Sprintf("%v", this.ExitStatus) + `,`,
2596		`ExitedAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ExitedAt), "Timestamp", "types1.Timestamp", 1), `&`, ``, 1) + `,`,
2597		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2598		`}`,
2599	}, "")
2600	return s
2601}
2602func valueToStringShim(v interface{}) string {
2603	rv := reflect.ValueOf(v)
2604	if rv.IsNil() {
2605		return "nil"
2606	}
2607	pv := reflect.Indirect(rv).Interface()
2608	return fmt.Sprintf("*%v", pv)
2609}
2610
2611type ShimService interface {
2612	State(ctx context.Context, req *StateRequest) (*StateResponse, error)
2613	Create(ctx context.Context, req *CreateTaskRequest) (*CreateTaskResponse, error)
2614	Start(ctx context.Context, req *StartRequest) (*StartResponse, error)
2615	Delete(ctx context.Context, req *types1.Empty) (*DeleteResponse, error)
2616	DeleteProcess(ctx context.Context, req *DeleteProcessRequest) (*DeleteResponse, error)
2617	ListPids(ctx context.Context, req *ListPidsRequest) (*ListPidsResponse, error)
2618	Pause(ctx context.Context, req *types1.Empty) (*types1.Empty, error)
2619	Resume(ctx context.Context, req *types1.Empty) (*types1.Empty, error)
2620	Checkpoint(ctx context.Context, req *CheckpointTaskRequest) (*types1.Empty, error)
2621	Kill(ctx context.Context, req *KillRequest) (*types1.Empty, error)
2622	Exec(ctx context.Context, req *ExecProcessRequest) (*types1.Empty, error)
2623	ResizePty(ctx context.Context, req *ResizePtyRequest) (*types1.Empty, error)
2624	CloseIO(ctx context.Context, req *CloseIORequest) (*types1.Empty, error)
2625	ShimInfo(ctx context.Context, req *types1.Empty) (*ShimInfoResponse, error)
2626	Update(ctx context.Context, req *UpdateTaskRequest) (*types1.Empty, error)
2627	Wait(ctx context.Context, req *WaitRequest) (*WaitResponse, error)
2628}
2629
2630func RegisterShimService(srv *github_com_containerd_ttrpc.Server, svc ShimService) {
2631	srv.Register("containerd.runtime.linux.shim.v1.Shim", map[string]github_com_containerd_ttrpc.Method{
2632		"State": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
2633			var req StateRequest
2634			if err := unmarshal(&req); err != nil {
2635				return nil, err
2636			}
2637			return svc.State(ctx, &req)
2638		},
2639		"Create": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
2640			var req CreateTaskRequest
2641			if err := unmarshal(&req); err != nil {
2642				return nil, err
2643			}
2644			return svc.Create(ctx, &req)
2645		},
2646		"Start": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
2647			var req StartRequest
2648			if err := unmarshal(&req); err != nil {
2649				return nil, err
2650			}
2651			return svc.Start(ctx, &req)
2652		},
2653		"Delete": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
2654			var req types1.Empty
2655			if err := unmarshal(&req); err != nil {
2656				return nil, err
2657			}
2658			return svc.Delete(ctx, &req)
2659		},
2660		"DeleteProcess": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
2661			var req DeleteProcessRequest
2662			if err := unmarshal(&req); err != nil {
2663				return nil, err
2664			}
2665			return svc.DeleteProcess(ctx, &req)
2666		},
2667		"ListPids": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
2668			var req ListPidsRequest
2669			if err := unmarshal(&req); err != nil {
2670				return nil, err
2671			}
2672			return svc.ListPids(ctx, &req)
2673		},
2674		"Pause": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
2675			var req types1.Empty
2676			if err := unmarshal(&req); err != nil {
2677				return nil, err
2678			}
2679			return svc.Pause(ctx, &req)
2680		},
2681		"Resume": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
2682			var req types1.Empty
2683			if err := unmarshal(&req); err != nil {
2684				return nil, err
2685			}
2686			return svc.Resume(ctx, &req)
2687		},
2688		"Checkpoint": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
2689			var req CheckpointTaskRequest
2690			if err := unmarshal(&req); err != nil {
2691				return nil, err
2692			}
2693			return svc.Checkpoint(ctx, &req)
2694		},
2695		"Kill": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
2696			var req KillRequest
2697			if err := unmarshal(&req); err != nil {
2698				return nil, err
2699			}
2700			return svc.Kill(ctx, &req)
2701		},
2702		"Exec": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
2703			var req ExecProcessRequest
2704			if err := unmarshal(&req); err != nil {
2705				return nil, err
2706			}
2707			return svc.Exec(ctx, &req)
2708		},
2709		"ResizePty": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
2710			var req ResizePtyRequest
2711			if err := unmarshal(&req); err != nil {
2712				return nil, err
2713			}
2714			return svc.ResizePty(ctx, &req)
2715		},
2716		"CloseIO": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
2717			var req CloseIORequest
2718			if err := unmarshal(&req); err != nil {
2719				return nil, err
2720			}
2721			return svc.CloseIO(ctx, &req)
2722		},
2723		"ShimInfo": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
2724			var req types1.Empty
2725			if err := unmarshal(&req); err != nil {
2726				return nil, err
2727			}
2728			return svc.ShimInfo(ctx, &req)
2729		},
2730		"Update": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
2731			var req UpdateTaskRequest
2732			if err := unmarshal(&req); err != nil {
2733				return nil, err
2734			}
2735			return svc.Update(ctx, &req)
2736		},
2737		"Wait": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
2738			var req WaitRequest
2739			if err := unmarshal(&req); err != nil {
2740				return nil, err
2741			}
2742			return svc.Wait(ctx, &req)
2743		},
2744	})
2745}
2746
2747type shimClient struct {
2748	client *github_com_containerd_ttrpc.Client
2749}
2750
2751func NewShimClient(client *github_com_containerd_ttrpc.Client) ShimService {
2752	return &shimClient{
2753		client: client,
2754	}
2755}
2756
2757func (c *shimClient) State(ctx context.Context, req *StateRequest) (*StateResponse, error) {
2758	var resp StateResponse
2759	if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "State", req, &resp); err != nil {
2760		return nil, err
2761	}
2762	return &resp, nil
2763}
2764
2765func (c *shimClient) Create(ctx context.Context, req *CreateTaskRequest) (*CreateTaskResponse, error) {
2766	var resp CreateTaskResponse
2767	if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "Create", req, &resp); err != nil {
2768		return nil, err
2769	}
2770	return &resp, nil
2771}
2772
2773func (c *shimClient) Start(ctx context.Context, req *StartRequest) (*StartResponse, error) {
2774	var resp StartResponse
2775	if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "Start", req, &resp); err != nil {
2776		return nil, err
2777	}
2778	return &resp, nil
2779}
2780
2781func (c *shimClient) Delete(ctx context.Context, req *types1.Empty) (*DeleteResponse, error) {
2782	var resp DeleteResponse
2783	if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "Delete", req, &resp); err != nil {
2784		return nil, err
2785	}
2786	return &resp, nil
2787}
2788
2789func (c *shimClient) DeleteProcess(ctx context.Context, req *DeleteProcessRequest) (*DeleteResponse, error) {
2790	var resp DeleteResponse
2791	if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "DeleteProcess", req, &resp); err != nil {
2792		return nil, err
2793	}
2794	return &resp, nil
2795}
2796
2797func (c *shimClient) ListPids(ctx context.Context, req *ListPidsRequest) (*ListPidsResponse, error) {
2798	var resp ListPidsResponse
2799	if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "ListPids", req, &resp); err != nil {
2800		return nil, err
2801	}
2802	return &resp, nil
2803}
2804
2805func (c *shimClient) Pause(ctx context.Context, req *types1.Empty) (*types1.Empty, error) {
2806	var resp types1.Empty
2807	if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "Pause", req, &resp); err != nil {
2808		return nil, err
2809	}
2810	return &resp, nil
2811}
2812
2813func (c *shimClient) Resume(ctx context.Context, req *types1.Empty) (*types1.Empty, error) {
2814	var resp types1.Empty
2815	if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "Resume", req, &resp); err != nil {
2816		return nil, err
2817	}
2818	return &resp, nil
2819}
2820
2821func (c *shimClient) Checkpoint(ctx context.Context, req *CheckpointTaskRequest) (*types1.Empty, error) {
2822	var resp types1.Empty
2823	if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "Checkpoint", req, &resp); err != nil {
2824		return nil, err
2825	}
2826	return &resp, nil
2827}
2828
2829func (c *shimClient) Kill(ctx context.Context, req *KillRequest) (*types1.Empty, error) {
2830	var resp types1.Empty
2831	if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "Kill", req, &resp); err != nil {
2832		return nil, err
2833	}
2834	return &resp, nil
2835}
2836
2837func (c *shimClient) Exec(ctx context.Context, req *ExecProcessRequest) (*types1.Empty, error) {
2838	var resp types1.Empty
2839	if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "Exec", req, &resp); err != nil {
2840		return nil, err
2841	}
2842	return &resp, nil
2843}
2844
2845func (c *shimClient) ResizePty(ctx context.Context, req *ResizePtyRequest) (*types1.Empty, error) {
2846	var resp types1.Empty
2847	if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "ResizePty", req, &resp); err != nil {
2848		return nil, err
2849	}
2850	return &resp, nil
2851}
2852
2853func (c *shimClient) CloseIO(ctx context.Context, req *CloseIORequest) (*types1.Empty, error) {
2854	var resp types1.Empty
2855	if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "CloseIO", req, &resp); err != nil {
2856		return nil, err
2857	}
2858	return &resp, nil
2859}
2860
2861func (c *shimClient) ShimInfo(ctx context.Context, req *types1.Empty) (*ShimInfoResponse, error) {
2862	var resp ShimInfoResponse
2863	if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "ShimInfo", req, &resp); err != nil {
2864		return nil, err
2865	}
2866	return &resp, nil
2867}
2868
2869func (c *shimClient) Update(ctx context.Context, req *UpdateTaskRequest) (*types1.Empty, error) {
2870	var resp types1.Empty
2871	if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "Update", req, &resp); err != nil {
2872		return nil, err
2873	}
2874	return &resp, nil
2875}
2876
2877func (c *shimClient) Wait(ctx context.Context, req *WaitRequest) (*WaitResponse, error) {
2878	var resp WaitResponse
2879	if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "Wait", req, &resp); err != nil {
2880		return nil, err
2881	}
2882	return &resp, nil
2883}
2884func (m *CreateTaskRequest) Unmarshal(dAtA []byte) error {
2885	l := len(dAtA)
2886	iNdEx := 0
2887	for iNdEx < l {
2888		preIndex := iNdEx
2889		var wire uint64
2890		for shift := uint(0); ; shift += 7 {
2891			if shift >= 64 {
2892				return ErrIntOverflowShim
2893			}
2894			if iNdEx >= l {
2895				return io.ErrUnexpectedEOF
2896			}
2897			b := dAtA[iNdEx]
2898			iNdEx++
2899			wire |= uint64(b&0x7F) << shift
2900			if b < 0x80 {
2901				break
2902			}
2903		}
2904		fieldNum := int32(wire >> 3)
2905		wireType := int(wire & 0x7)
2906		if wireType == 4 {
2907			return fmt.Errorf("proto: CreateTaskRequest: wiretype end group for non-group")
2908		}
2909		if fieldNum <= 0 {
2910			return fmt.Errorf("proto: CreateTaskRequest: illegal tag %d (wire type %d)", fieldNum, wire)
2911		}
2912		switch fieldNum {
2913		case 1:
2914			if wireType != 2 {
2915				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
2916			}
2917			var stringLen uint64
2918			for shift := uint(0); ; shift += 7 {
2919				if shift >= 64 {
2920					return ErrIntOverflowShim
2921				}
2922				if iNdEx >= l {
2923					return io.ErrUnexpectedEOF
2924				}
2925				b := dAtA[iNdEx]
2926				iNdEx++
2927				stringLen |= uint64(b&0x7F) << shift
2928				if b < 0x80 {
2929					break
2930				}
2931			}
2932			intStringLen := int(stringLen)
2933			if intStringLen < 0 {
2934				return ErrInvalidLengthShim
2935			}
2936			postIndex := iNdEx + intStringLen
2937			if postIndex < 0 {
2938				return ErrInvalidLengthShim
2939			}
2940			if postIndex > l {
2941				return io.ErrUnexpectedEOF
2942			}
2943			m.ID = string(dAtA[iNdEx:postIndex])
2944			iNdEx = postIndex
2945		case 2:
2946			if wireType != 2 {
2947				return fmt.Errorf("proto: wrong wireType = %d for field Bundle", wireType)
2948			}
2949			var stringLen uint64
2950			for shift := uint(0); ; shift += 7 {
2951				if shift >= 64 {
2952					return ErrIntOverflowShim
2953				}
2954				if iNdEx >= l {
2955					return io.ErrUnexpectedEOF
2956				}
2957				b := dAtA[iNdEx]
2958				iNdEx++
2959				stringLen |= uint64(b&0x7F) << shift
2960				if b < 0x80 {
2961					break
2962				}
2963			}
2964			intStringLen := int(stringLen)
2965			if intStringLen < 0 {
2966				return ErrInvalidLengthShim
2967			}
2968			postIndex := iNdEx + intStringLen
2969			if postIndex < 0 {
2970				return ErrInvalidLengthShim
2971			}
2972			if postIndex > l {
2973				return io.ErrUnexpectedEOF
2974			}
2975			m.Bundle = string(dAtA[iNdEx:postIndex])
2976			iNdEx = postIndex
2977		case 3:
2978			if wireType != 2 {
2979				return fmt.Errorf("proto: wrong wireType = %d for field Runtime", wireType)
2980			}
2981			var stringLen uint64
2982			for shift := uint(0); ; shift += 7 {
2983				if shift >= 64 {
2984					return ErrIntOverflowShim
2985				}
2986				if iNdEx >= l {
2987					return io.ErrUnexpectedEOF
2988				}
2989				b := dAtA[iNdEx]
2990				iNdEx++
2991				stringLen |= uint64(b&0x7F) << shift
2992				if b < 0x80 {
2993					break
2994				}
2995			}
2996			intStringLen := int(stringLen)
2997			if intStringLen < 0 {
2998				return ErrInvalidLengthShim
2999			}
3000			postIndex := iNdEx + intStringLen
3001			if postIndex < 0 {
3002				return ErrInvalidLengthShim
3003			}
3004			if postIndex > l {
3005				return io.ErrUnexpectedEOF
3006			}
3007			m.Runtime = string(dAtA[iNdEx:postIndex])
3008			iNdEx = postIndex
3009		case 4:
3010			if wireType != 2 {
3011				return fmt.Errorf("proto: wrong wireType = %d for field Rootfs", wireType)
3012			}
3013			var msglen int
3014			for shift := uint(0); ; shift += 7 {
3015				if shift >= 64 {
3016					return ErrIntOverflowShim
3017				}
3018				if iNdEx >= l {
3019					return io.ErrUnexpectedEOF
3020				}
3021				b := dAtA[iNdEx]
3022				iNdEx++
3023				msglen |= int(b&0x7F) << shift
3024				if b < 0x80 {
3025					break
3026				}
3027			}
3028			if msglen < 0 {
3029				return ErrInvalidLengthShim
3030			}
3031			postIndex := iNdEx + msglen
3032			if postIndex < 0 {
3033				return ErrInvalidLengthShim
3034			}
3035			if postIndex > l {
3036				return io.ErrUnexpectedEOF
3037			}
3038			m.Rootfs = append(m.Rootfs, &types.Mount{})
3039			if err := m.Rootfs[len(m.Rootfs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3040				return err
3041			}
3042			iNdEx = postIndex
3043		case 5:
3044			if wireType != 0 {
3045				return fmt.Errorf("proto: wrong wireType = %d for field Terminal", wireType)
3046			}
3047			var v int
3048			for shift := uint(0); ; shift += 7 {
3049				if shift >= 64 {
3050					return ErrIntOverflowShim
3051				}
3052				if iNdEx >= l {
3053					return io.ErrUnexpectedEOF
3054				}
3055				b := dAtA[iNdEx]
3056				iNdEx++
3057				v |= int(b&0x7F) << shift
3058				if b < 0x80 {
3059					break
3060				}
3061			}
3062			m.Terminal = bool(v != 0)
3063		case 6:
3064			if wireType != 2 {
3065				return fmt.Errorf("proto: wrong wireType = %d for field Stdin", wireType)
3066			}
3067			var stringLen uint64
3068			for shift := uint(0); ; shift += 7 {
3069				if shift >= 64 {
3070					return ErrIntOverflowShim
3071				}
3072				if iNdEx >= l {
3073					return io.ErrUnexpectedEOF
3074				}
3075				b := dAtA[iNdEx]
3076				iNdEx++
3077				stringLen |= uint64(b&0x7F) << shift
3078				if b < 0x80 {
3079					break
3080				}
3081			}
3082			intStringLen := int(stringLen)
3083			if intStringLen < 0 {
3084				return ErrInvalidLengthShim
3085			}
3086			postIndex := iNdEx + intStringLen
3087			if postIndex < 0 {
3088				return ErrInvalidLengthShim
3089			}
3090			if postIndex > l {
3091				return io.ErrUnexpectedEOF
3092			}
3093			m.Stdin = string(dAtA[iNdEx:postIndex])
3094			iNdEx = postIndex
3095		case 7:
3096			if wireType != 2 {
3097				return fmt.Errorf("proto: wrong wireType = %d for field Stdout", wireType)
3098			}
3099			var stringLen uint64
3100			for shift := uint(0); ; shift += 7 {
3101				if shift >= 64 {
3102					return ErrIntOverflowShim
3103				}
3104				if iNdEx >= l {
3105					return io.ErrUnexpectedEOF
3106				}
3107				b := dAtA[iNdEx]
3108				iNdEx++
3109				stringLen |= uint64(b&0x7F) << shift
3110				if b < 0x80 {
3111					break
3112				}
3113			}
3114			intStringLen := int(stringLen)
3115			if intStringLen < 0 {
3116				return ErrInvalidLengthShim
3117			}
3118			postIndex := iNdEx + intStringLen
3119			if postIndex < 0 {
3120				return ErrInvalidLengthShim
3121			}
3122			if postIndex > l {
3123				return io.ErrUnexpectedEOF
3124			}
3125			m.Stdout = string(dAtA[iNdEx:postIndex])
3126			iNdEx = postIndex
3127		case 8:
3128			if wireType != 2 {
3129				return fmt.Errorf("proto: wrong wireType = %d for field Stderr", wireType)
3130			}
3131			var stringLen uint64
3132			for shift := uint(0); ; shift += 7 {
3133				if shift >= 64 {
3134					return ErrIntOverflowShim
3135				}
3136				if iNdEx >= l {
3137					return io.ErrUnexpectedEOF
3138				}
3139				b := dAtA[iNdEx]
3140				iNdEx++
3141				stringLen |= uint64(b&0x7F) << shift
3142				if b < 0x80 {
3143					break
3144				}
3145			}
3146			intStringLen := int(stringLen)
3147			if intStringLen < 0 {
3148				return ErrInvalidLengthShim
3149			}
3150			postIndex := iNdEx + intStringLen
3151			if postIndex < 0 {
3152				return ErrInvalidLengthShim
3153			}
3154			if postIndex > l {
3155				return io.ErrUnexpectedEOF
3156			}
3157			m.Stderr = string(dAtA[iNdEx:postIndex])
3158			iNdEx = postIndex
3159		case 9:
3160			if wireType != 2 {
3161				return fmt.Errorf("proto: wrong wireType = %d for field Checkpoint", wireType)
3162			}
3163			var stringLen uint64
3164			for shift := uint(0); ; shift += 7 {
3165				if shift >= 64 {
3166					return ErrIntOverflowShim
3167				}
3168				if iNdEx >= l {
3169					return io.ErrUnexpectedEOF
3170				}
3171				b := dAtA[iNdEx]
3172				iNdEx++
3173				stringLen |= uint64(b&0x7F) << shift
3174				if b < 0x80 {
3175					break
3176				}
3177			}
3178			intStringLen := int(stringLen)
3179			if intStringLen < 0 {
3180				return ErrInvalidLengthShim
3181			}
3182			postIndex := iNdEx + intStringLen
3183			if postIndex < 0 {
3184				return ErrInvalidLengthShim
3185			}
3186			if postIndex > l {
3187				return io.ErrUnexpectedEOF
3188			}
3189			m.Checkpoint = string(dAtA[iNdEx:postIndex])
3190			iNdEx = postIndex
3191		case 10:
3192			if wireType != 2 {
3193				return fmt.Errorf("proto: wrong wireType = %d for field ParentCheckpoint", wireType)
3194			}
3195			var stringLen uint64
3196			for shift := uint(0); ; shift += 7 {
3197				if shift >= 64 {
3198					return ErrIntOverflowShim
3199				}
3200				if iNdEx >= l {
3201					return io.ErrUnexpectedEOF
3202				}
3203				b := dAtA[iNdEx]
3204				iNdEx++
3205				stringLen |= uint64(b&0x7F) << shift
3206				if b < 0x80 {
3207					break
3208				}
3209			}
3210			intStringLen := int(stringLen)
3211			if intStringLen < 0 {
3212				return ErrInvalidLengthShim
3213			}
3214			postIndex := iNdEx + intStringLen
3215			if postIndex < 0 {
3216				return ErrInvalidLengthShim
3217			}
3218			if postIndex > l {
3219				return io.ErrUnexpectedEOF
3220			}
3221			m.ParentCheckpoint = string(dAtA[iNdEx:postIndex])
3222			iNdEx = postIndex
3223		case 11:
3224			if wireType != 2 {
3225				return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
3226			}
3227			var msglen int
3228			for shift := uint(0); ; shift += 7 {
3229				if shift >= 64 {
3230					return ErrIntOverflowShim
3231				}
3232				if iNdEx >= l {
3233					return io.ErrUnexpectedEOF
3234				}
3235				b := dAtA[iNdEx]
3236				iNdEx++
3237				msglen |= int(b&0x7F) << shift
3238				if b < 0x80 {
3239					break
3240				}
3241			}
3242			if msglen < 0 {
3243				return ErrInvalidLengthShim
3244			}
3245			postIndex := iNdEx + msglen
3246			if postIndex < 0 {
3247				return ErrInvalidLengthShim
3248			}
3249			if postIndex > l {
3250				return io.ErrUnexpectedEOF
3251			}
3252			if m.Options == nil {
3253				m.Options = &types1.Any{}
3254			}
3255			if err := m.Options.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3256				return err
3257			}
3258			iNdEx = postIndex
3259		default:
3260			iNdEx = preIndex
3261			skippy, err := skipShim(dAtA[iNdEx:])
3262			if err != nil {
3263				return err
3264			}
3265			if (skippy < 0) || (iNdEx+skippy) < 0 {
3266				return ErrInvalidLengthShim
3267			}
3268			if (iNdEx + skippy) > l {
3269				return io.ErrUnexpectedEOF
3270			}
3271			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
3272			iNdEx += skippy
3273		}
3274	}
3275
3276	if iNdEx > l {
3277		return io.ErrUnexpectedEOF
3278	}
3279	return nil
3280}
3281func (m *CreateTaskResponse) Unmarshal(dAtA []byte) error {
3282	l := len(dAtA)
3283	iNdEx := 0
3284	for iNdEx < l {
3285		preIndex := iNdEx
3286		var wire uint64
3287		for shift := uint(0); ; shift += 7 {
3288			if shift >= 64 {
3289				return ErrIntOverflowShim
3290			}
3291			if iNdEx >= l {
3292				return io.ErrUnexpectedEOF
3293			}
3294			b := dAtA[iNdEx]
3295			iNdEx++
3296			wire |= uint64(b&0x7F) << shift
3297			if b < 0x80 {
3298				break
3299			}
3300		}
3301		fieldNum := int32(wire >> 3)
3302		wireType := int(wire & 0x7)
3303		if wireType == 4 {
3304			return fmt.Errorf("proto: CreateTaskResponse: wiretype end group for non-group")
3305		}
3306		if fieldNum <= 0 {
3307			return fmt.Errorf("proto: CreateTaskResponse: illegal tag %d (wire type %d)", fieldNum, wire)
3308		}
3309		switch fieldNum {
3310		case 1:
3311			if wireType != 0 {
3312				return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType)
3313			}
3314			m.Pid = 0
3315			for shift := uint(0); ; shift += 7 {
3316				if shift >= 64 {
3317					return ErrIntOverflowShim
3318				}
3319				if iNdEx >= l {
3320					return io.ErrUnexpectedEOF
3321				}
3322				b := dAtA[iNdEx]
3323				iNdEx++
3324				m.Pid |= uint32(b&0x7F) << shift
3325				if b < 0x80 {
3326					break
3327				}
3328			}
3329		default:
3330			iNdEx = preIndex
3331			skippy, err := skipShim(dAtA[iNdEx:])
3332			if err != nil {
3333				return err
3334			}
3335			if (skippy < 0) || (iNdEx+skippy) < 0 {
3336				return ErrInvalidLengthShim
3337			}
3338			if (iNdEx + skippy) > l {
3339				return io.ErrUnexpectedEOF
3340			}
3341			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
3342			iNdEx += skippy
3343		}
3344	}
3345
3346	if iNdEx > l {
3347		return io.ErrUnexpectedEOF
3348	}
3349	return nil
3350}
3351func (m *DeleteResponse) Unmarshal(dAtA []byte) error {
3352	l := len(dAtA)
3353	iNdEx := 0
3354	for iNdEx < l {
3355		preIndex := iNdEx
3356		var wire uint64
3357		for shift := uint(0); ; shift += 7 {
3358			if shift >= 64 {
3359				return ErrIntOverflowShim
3360			}
3361			if iNdEx >= l {
3362				return io.ErrUnexpectedEOF
3363			}
3364			b := dAtA[iNdEx]
3365			iNdEx++
3366			wire |= uint64(b&0x7F) << shift
3367			if b < 0x80 {
3368				break
3369			}
3370		}
3371		fieldNum := int32(wire >> 3)
3372		wireType := int(wire & 0x7)
3373		if wireType == 4 {
3374			return fmt.Errorf("proto: DeleteResponse: wiretype end group for non-group")
3375		}
3376		if fieldNum <= 0 {
3377			return fmt.Errorf("proto: DeleteResponse: illegal tag %d (wire type %d)", fieldNum, wire)
3378		}
3379		switch fieldNum {
3380		case 1:
3381			if wireType != 0 {
3382				return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType)
3383			}
3384			m.Pid = 0
3385			for shift := uint(0); ; shift += 7 {
3386				if shift >= 64 {
3387					return ErrIntOverflowShim
3388				}
3389				if iNdEx >= l {
3390					return io.ErrUnexpectedEOF
3391				}
3392				b := dAtA[iNdEx]
3393				iNdEx++
3394				m.Pid |= uint32(b&0x7F) << shift
3395				if b < 0x80 {
3396					break
3397				}
3398			}
3399		case 2:
3400			if wireType != 0 {
3401				return fmt.Errorf("proto: wrong wireType = %d for field ExitStatus", wireType)
3402			}
3403			m.ExitStatus = 0
3404			for shift := uint(0); ; shift += 7 {
3405				if shift >= 64 {
3406					return ErrIntOverflowShim
3407				}
3408				if iNdEx >= l {
3409					return io.ErrUnexpectedEOF
3410				}
3411				b := dAtA[iNdEx]
3412				iNdEx++
3413				m.ExitStatus |= uint32(b&0x7F) << shift
3414				if b < 0x80 {
3415					break
3416				}
3417			}
3418		case 3:
3419			if wireType != 2 {
3420				return fmt.Errorf("proto: wrong wireType = %d for field ExitedAt", wireType)
3421			}
3422			var msglen int
3423			for shift := uint(0); ; shift += 7 {
3424				if shift >= 64 {
3425					return ErrIntOverflowShim
3426				}
3427				if iNdEx >= l {
3428					return io.ErrUnexpectedEOF
3429				}
3430				b := dAtA[iNdEx]
3431				iNdEx++
3432				msglen |= int(b&0x7F) << shift
3433				if b < 0x80 {
3434					break
3435				}
3436			}
3437			if msglen < 0 {
3438				return ErrInvalidLengthShim
3439			}
3440			postIndex := iNdEx + msglen
3441			if postIndex < 0 {
3442				return ErrInvalidLengthShim
3443			}
3444			if postIndex > l {
3445				return io.ErrUnexpectedEOF
3446			}
3447			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.ExitedAt, dAtA[iNdEx:postIndex]); err != nil {
3448				return err
3449			}
3450			iNdEx = postIndex
3451		default:
3452			iNdEx = preIndex
3453			skippy, err := skipShim(dAtA[iNdEx:])
3454			if err != nil {
3455				return err
3456			}
3457			if (skippy < 0) || (iNdEx+skippy) < 0 {
3458				return ErrInvalidLengthShim
3459			}
3460			if (iNdEx + skippy) > l {
3461				return io.ErrUnexpectedEOF
3462			}
3463			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
3464			iNdEx += skippy
3465		}
3466	}
3467
3468	if iNdEx > l {
3469		return io.ErrUnexpectedEOF
3470	}
3471	return nil
3472}
3473func (m *DeleteProcessRequest) Unmarshal(dAtA []byte) error {
3474	l := len(dAtA)
3475	iNdEx := 0
3476	for iNdEx < l {
3477		preIndex := iNdEx
3478		var wire uint64
3479		for shift := uint(0); ; shift += 7 {
3480			if shift >= 64 {
3481				return ErrIntOverflowShim
3482			}
3483			if iNdEx >= l {
3484				return io.ErrUnexpectedEOF
3485			}
3486			b := dAtA[iNdEx]
3487			iNdEx++
3488			wire |= uint64(b&0x7F) << shift
3489			if b < 0x80 {
3490				break
3491			}
3492		}
3493		fieldNum := int32(wire >> 3)
3494		wireType := int(wire & 0x7)
3495		if wireType == 4 {
3496			return fmt.Errorf("proto: DeleteProcessRequest: wiretype end group for non-group")
3497		}
3498		if fieldNum <= 0 {
3499			return fmt.Errorf("proto: DeleteProcessRequest: illegal tag %d (wire type %d)", fieldNum, wire)
3500		}
3501		switch fieldNum {
3502		case 1:
3503			if wireType != 2 {
3504				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
3505			}
3506			var stringLen uint64
3507			for shift := uint(0); ; shift += 7 {
3508				if shift >= 64 {
3509					return ErrIntOverflowShim
3510				}
3511				if iNdEx >= l {
3512					return io.ErrUnexpectedEOF
3513				}
3514				b := dAtA[iNdEx]
3515				iNdEx++
3516				stringLen |= uint64(b&0x7F) << shift
3517				if b < 0x80 {
3518					break
3519				}
3520			}
3521			intStringLen := int(stringLen)
3522			if intStringLen < 0 {
3523				return ErrInvalidLengthShim
3524			}
3525			postIndex := iNdEx + intStringLen
3526			if postIndex < 0 {
3527				return ErrInvalidLengthShim
3528			}
3529			if postIndex > l {
3530				return io.ErrUnexpectedEOF
3531			}
3532			m.ID = string(dAtA[iNdEx:postIndex])
3533			iNdEx = postIndex
3534		default:
3535			iNdEx = preIndex
3536			skippy, err := skipShim(dAtA[iNdEx:])
3537			if err != nil {
3538				return err
3539			}
3540			if (skippy < 0) || (iNdEx+skippy) < 0 {
3541				return ErrInvalidLengthShim
3542			}
3543			if (iNdEx + skippy) > l {
3544				return io.ErrUnexpectedEOF
3545			}
3546			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
3547			iNdEx += skippy
3548		}
3549	}
3550
3551	if iNdEx > l {
3552		return io.ErrUnexpectedEOF
3553	}
3554	return nil
3555}
3556func (m *ExecProcessRequest) Unmarshal(dAtA []byte) error {
3557	l := len(dAtA)
3558	iNdEx := 0
3559	for iNdEx < l {
3560		preIndex := iNdEx
3561		var wire uint64
3562		for shift := uint(0); ; shift += 7 {
3563			if shift >= 64 {
3564				return ErrIntOverflowShim
3565			}
3566			if iNdEx >= l {
3567				return io.ErrUnexpectedEOF
3568			}
3569			b := dAtA[iNdEx]
3570			iNdEx++
3571			wire |= uint64(b&0x7F) << shift
3572			if b < 0x80 {
3573				break
3574			}
3575		}
3576		fieldNum := int32(wire >> 3)
3577		wireType := int(wire & 0x7)
3578		if wireType == 4 {
3579			return fmt.Errorf("proto: ExecProcessRequest: wiretype end group for non-group")
3580		}
3581		if fieldNum <= 0 {
3582			return fmt.Errorf("proto: ExecProcessRequest: illegal tag %d (wire type %d)", fieldNum, wire)
3583		}
3584		switch fieldNum {
3585		case 1:
3586			if wireType != 2 {
3587				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
3588			}
3589			var stringLen uint64
3590			for shift := uint(0); ; shift += 7 {
3591				if shift >= 64 {
3592					return ErrIntOverflowShim
3593				}
3594				if iNdEx >= l {
3595					return io.ErrUnexpectedEOF
3596				}
3597				b := dAtA[iNdEx]
3598				iNdEx++
3599				stringLen |= uint64(b&0x7F) << shift
3600				if b < 0x80 {
3601					break
3602				}
3603			}
3604			intStringLen := int(stringLen)
3605			if intStringLen < 0 {
3606				return ErrInvalidLengthShim
3607			}
3608			postIndex := iNdEx + intStringLen
3609			if postIndex < 0 {
3610				return ErrInvalidLengthShim
3611			}
3612			if postIndex > l {
3613				return io.ErrUnexpectedEOF
3614			}
3615			m.ID = string(dAtA[iNdEx:postIndex])
3616			iNdEx = postIndex
3617		case 2:
3618			if wireType != 0 {
3619				return fmt.Errorf("proto: wrong wireType = %d for field Terminal", wireType)
3620			}
3621			var v int
3622			for shift := uint(0); ; shift += 7 {
3623				if shift >= 64 {
3624					return ErrIntOverflowShim
3625				}
3626				if iNdEx >= l {
3627					return io.ErrUnexpectedEOF
3628				}
3629				b := dAtA[iNdEx]
3630				iNdEx++
3631				v |= int(b&0x7F) << shift
3632				if b < 0x80 {
3633					break
3634				}
3635			}
3636			m.Terminal = bool(v != 0)
3637		case 3:
3638			if wireType != 2 {
3639				return fmt.Errorf("proto: wrong wireType = %d for field Stdin", wireType)
3640			}
3641			var stringLen uint64
3642			for shift := uint(0); ; shift += 7 {
3643				if shift >= 64 {
3644					return ErrIntOverflowShim
3645				}
3646				if iNdEx >= l {
3647					return io.ErrUnexpectedEOF
3648				}
3649				b := dAtA[iNdEx]
3650				iNdEx++
3651				stringLen |= uint64(b&0x7F) << shift
3652				if b < 0x80 {
3653					break
3654				}
3655			}
3656			intStringLen := int(stringLen)
3657			if intStringLen < 0 {
3658				return ErrInvalidLengthShim
3659			}
3660			postIndex := iNdEx + intStringLen
3661			if postIndex < 0 {
3662				return ErrInvalidLengthShim
3663			}
3664			if postIndex > l {
3665				return io.ErrUnexpectedEOF
3666			}
3667			m.Stdin = string(dAtA[iNdEx:postIndex])
3668			iNdEx = postIndex
3669		case 4:
3670			if wireType != 2 {
3671				return fmt.Errorf("proto: wrong wireType = %d for field Stdout", wireType)
3672			}
3673			var stringLen uint64
3674			for shift := uint(0); ; shift += 7 {
3675				if shift >= 64 {
3676					return ErrIntOverflowShim
3677				}
3678				if iNdEx >= l {
3679					return io.ErrUnexpectedEOF
3680				}
3681				b := dAtA[iNdEx]
3682				iNdEx++
3683				stringLen |= uint64(b&0x7F) << shift
3684				if b < 0x80 {
3685					break
3686				}
3687			}
3688			intStringLen := int(stringLen)
3689			if intStringLen < 0 {
3690				return ErrInvalidLengthShim
3691			}
3692			postIndex := iNdEx + intStringLen
3693			if postIndex < 0 {
3694				return ErrInvalidLengthShim
3695			}
3696			if postIndex > l {
3697				return io.ErrUnexpectedEOF
3698			}
3699			m.Stdout = string(dAtA[iNdEx:postIndex])
3700			iNdEx = postIndex
3701		case 5:
3702			if wireType != 2 {
3703				return fmt.Errorf("proto: wrong wireType = %d for field Stderr", wireType)
3704			}
3705			var stringLen uint64
3706			for shift := uint(0); ; shift += 7 {
3707				if shift >= 64 {
3708					return ErrIntOverflowShim
3709				}
3710				if iNdEx >= l {
3711					return io.ErrUnexpectedEOF
3712				}
3713				b := dAtA[iNdEx]
3714				iNdEx++
3715				stringLen |= uint64(b&0x7F) << shift
3716				if b < 0x80 {
3717					break
3718				}
3719			}
3720			intStringLen := int(stringLen)
3721			if intStringLen < 0 {
3722				return ErrInvalidLengthShim
3723			}
3724			postIndex := iNdEx + intStringLen
3725			if postIndex < 0 {
3726				return ErrInvalidLengthShim
3727			}
3728			if postIndex > l {
3729				return io.ErrUnexpectedEOF
3730			}
3731			m.Stderr = string(dAtA[iNdEx:postIndex])
3732			iNdEx = postIndex
3733		case 6:
3734			if wireType != 2 {
3735				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
3736			}
3737			var msglen int
3738			for shift := uint(0); ; shift += 7 {
3739				if shift >= 64 {
3740					return ErrIntOverflowShim
3741				}
3742				if iNdEx >= l {
3743					return io.ErrUnexpectedEOF
3744				}
3745				b := dAtA[iNdEx]
3746				iNdEx++
3747				msglen |= int(b&0x7F) << shift
3748				if b < 0x80 {
3749					break
3750				}
3751			}
3752			if msglen < 0 {
3753				return ErrInvalidLengthShim
3754			}
3755			postIndex := iNdEx + msglen
3756			if postIndex < 0 {
3757				return ErrInvalidLengthShim
3758			}
3759			if postIndex > l {
3760				return io.ErrUnexpectedEOF
3761			}
3762			if m.Spec == nil {
3763				m.Spec = &types1.Any{}
3764			}
3765			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3766				return err
3767			}
3768			iNdEx = postIndex
3769		default:
3770			iNdEx = preIndex
3771			skippy, err := skipShim(dAtA[iNdEx:])
3772			if err != nil {
3773				return err
3774			}
3775			if (skippy < 0) || (iNdEx+skippy) < 0 {
3776				return ErrInvalidLengthShim
3777			}
3778			if (iNdEx + skippy) > l {
3779				return io.ErrUnexpectedEOF
3780			}
3781			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
3782			iNdEx += skippy
3783		}
3784	}
3785
3786	if iNdEx > l {
3787		return io.ErrUnexpectedEOF
3788	}
3789	return nil
3790}
3791func (m *ExecProcessResponse) Unmarshal(dAtA []byte) error {
3792	l := len(dAtA)
3793	iNdEx := 0
3794	for iNdEx < l {
3795		preIndex := iNdEx
3796		var wire uint64
3797		for shift := uint(0); ; shift += 7 {
3798			if shift >= 64 {
3799				return ErrIntOverflowShim
3800			}
3801			if iNdEx >= l {
3802				return io.ErrUnexpectedEOF
3803			}
3804			b := dAtA[iNdEx]
3805			iNdEx++
3806			wire |= uint64(b&0x7F) << shift
3807			if b < 0x80 {
3808				break
3809			}
3810		}
3811		fieldNum := int32(wire >> 3)
3812		wireType := int(wire & 0x7)
3813		if wireType == 4 {
3814			return fmt.Errorf("proto: ExecProcessResponse: wiretype end group for non-group")
3815		}
3816		if fieldNum <= 0 {
3817			return fmt.Errorf("proto: ExecProcessResponse: illegal tag %d (wire type %d)", fieldNum, wire)
3818		}
3819		switch fieldNum {
3820		default:
3821			iNdEx = preIndex
3822			skippy, err := skipShim(dAtA[iNdEx:])
3823			if err != nil {
3824				return err
3825			}
3826			if (skippy < 0) || (iNdEx+skippy) < 0 {
3827				return ErrInvalidLengthShim
3828			}
3829			if (iNdEx + skippy) > l {
3830				return io.ErrUnexpectedEOF
3831			}
3832			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
3833			iNdEx += skippy
3834		}
3835	}
3836
3837	if iNdEx > l {
3838		return io.ErrUnexpectedEOF
3839	}
3840	return nil
3841}
3842func (m *ResizePtyRequest) Unmarshal(dAtA []byte) error {
3843	l := len(dAtA)
3844	iNdEx := 0
3845	for iNdEx < l {
3846		preIndex := iNdEx
3847		var wire uint64
3848		for shift := uint(0); ; shift += 7 {
3849			if shift >= 64 {
3850				return ErrIntOverflowShim
3851			}
3852			if iNdEx >= l {
3853				return io.ErrUnexpectedEOF
3854			}
3855			b := dAtA[iNdEx]
3856			iNdEx++
3857			wire |= uint64(b&0x7F) << shift
3858			if b < 0x80 {
3859				break
3860			}
3861		}
3862		fieldNum := int32(wire >> 3)
3863		wireType := int(wire & 0x7)
3864		if wireType == 4 {
3865			return fmt.Errorf("proto: ResizePtyRequest: wiretype end group for non-group")
3866		}
3867		if fieldNum <= 0 {
3868			return fmt.Errorf("proto: ResizePtyRequest: illegal tag %d (wire type %d)", fieldNum, wire)
3869		}
3870		switch fieldNum {
3871		case 1:
3872			if wireType != 2 {
3873				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
3874			}
3875			var stringLen uint64
3876			for shift := uint(0); ; shift += 7 {
3877				if shift >= 64 {
3878					return ErrIntOverflowShim
3879				}
3880				if iNdEx >= l {
3881					return io.ErrUnexpectedEOF
3882				}
3883				b := dAtA[iNdEx]
3884				iNdEx++
3885				stringLen |= uint64(b&0x7F) << shift
3886				if b < 0x80 {
3887					break
3888				}
3889			}
3890			intStringLen := int(stringLen)
3891			if intStringLen < 0 {
3892				return ErrInvalidLengthShim
3893			}
3894			postIndex := iNdEx + intStringLen
3895			if postIndex < 0 {
3896				return ErrInvalidLengthShim
3897			}
3898			if postIndex > l {
3899				return io.ErrUnexpectedEOF
3900			}
3901			m.ID = string(dAtA[iNdEx:postIndex])
3902			iNdEx = postIndex
3903		case 2:
3904			if wireType != 0 {
3905				return fmt.Errorf("proto: wrong wireType = %d for field Width", wireType)
3906			}
3907			m.Width = 0
3908			for shift := uint(0); ; shift += 7 {
3909				if shift >= 64 {
3910					return ErrIntOverflowShim
3911				}
3912				if iNdEx >= l {
3913					return io.ErrUnexpectedEOF
3914				}
3915				b := dAtA[iNdEx]
3916				iNdEx++
3917				m.Width |= uint32(b&0x7F) << shift
3918				if b < 0x80 {
3919					break
3920				}
3921			}
3922		case 3:
3923			if wireType != 0 {
3924				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
3925			}
3926			m.Height = 0
3927			for shift := uint(0); ; shift += 7 {
3928				if shift >= 64 {
3929					return ErrIntOverflowShim
3930				}
3931				if iNdEx >= l {
3932					return io.ErrUnexpectedEOF
3933				}
3934				b := dAtA[iNdEx]
3935				iNdEx++
3936				m.Height |= uint32(b&0x7F) << shift
3937				if b < 0x80 {
3938					break
3939				}
3940			}
3941		default:
3942			iNdEx = preIndex
3943			skippy, err := skipShim(dAtA[iNdEx:])
3944			if err != nil {
3945				return err
3946			}
3947			if (skippy < 0) || (iNdEx+skippy) < 0 {
3948				return ErrInvalidLengthShim
3949			}
3950			if (iNdEx + skippy) > l {
3951				return io.ErrUnexpectedEOF
3952			}
3953			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
3954			iNdEx += skippy
3955		}
3956	}
3957
3958	if iNdEx > l {
3959		return io.ErrUnexpectedEOF
3960	}
3961	return nil
3962}
3963func (m *StateRequest) Unmarshal(dAtA []byte) error {
3964	l := len(dAtA)
3965	iNdEx := 0
3966	for iNdEx < l {
3967		preIndex := iNdEx
3968		var wire uint64
3969		for shift := uint(0); ; shift += 7 {
3970			if shift >= 64 {
3971				return ErrIntOverflowShim
3972			}
3973			if iNdEx >= l {
3974				return io.ErrUnexpectedEOF
3975			}
3976			b := dAtA[iNdEx]
3977			iNdEx++
3978			wire |= uint64(b&0x7F) << shift
3979			if b < 0x80 {
3980				break
3981			}
3982		}
3983		fieldNum := int32(wire >> 3)
3984		wireType := int(wire & 0x7)
3985		if wireType == 4 {
3986			return fmt.Errorf("proto: StateRequest: wiretype end group for non-group")
3987		}
3988		if fieldNum <= 0 {
3989			return fmt.Errorf("proto: StateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
3990		}
3991		switch fieldNum {
3992		case 1:
3993			if wireType != 2 {
3994				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
3995			}
3996			var stringLen uint64
3997			for shift := uint(0); ; shift += 7 {
3998				if shift >= 64 {
3999					return ErrIntOverflowShim
4000				}
4001				if iNdEx >= l {
4002					return io.ErrUnexpectedEOF
4003				}
4004				b := dAtA[iNdEx]
4005				iNdEx++
4006				stringLen |= uint64(b&0x7F) << shift
4007				if b < 0x80 {
4008					break
4009				}
4010			}
4011			intStringLen := int(stringLen)
4012			if intStringLen < 0 {
4013				return ErrInvalidLengthShim
4014			}
4015			postIndex := iNdEx + intStringLen
4016			if postIndex < 0 {
4017				return ErrInvalidLengthShim
4018			}
4019			if postIndex > l {
4020				return io.ErrUnexpectedEOF
4021			}
4022			m.ID = string(dAtA[iNdEx:postIndex])
4023			iNdEx = postIndex
4024		default:
4025			iNdEx = preIndex
4026			skippy, err := skipShim(dAtA[iNdEx:])
4027			if err != nil {
4028				return err
4029			}
4030			if (skippy < 0) || (iNdEx+skippy) < 0 {
4031				return ErrInvalidLengthShim
4032			}
4033			if (iNdEx + skippy) > l {
4034				return io.ErrUnexpectedEOF
4035			}
4036			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
4037			iNdEx += skippy
4038		}
4039	}
4040
4041	if iNdEx > l {
4042		return io.ErrUnexpectedEOF
4043	}
4044	return nil
4045}
4046func (m *StateResponse) Unmarshal(dAtA []byte) error {
4047	l := len(dAtA)
4048	iNdEx := 0
4049	for iNdEx < l {
4050		preIndex := iNdEx
4051		var wire uint64
4052		for shift := uint(0); ; shift += 7 {
4053			if shift >= 64 {
4054				return ErrIntOverflowShim
4055			}
4056			if iNdEx >= l {
4057				return io.ErrUnexpectedEOF
4058			}
4059			b := dAtA[iNdEx]
4060			iNdEx++
4061			wire |= uint64(b&0x7F) << shift
4062			if b < 0x80 {
4063				break
4064			}
4065		}
4066		fieldNum := int32(wire >> 3)
4067		wireType := int(wire & 0x7)
4068		if wireType == 4 {
4069			return fmt.Errorf("proto: StateResponse: wiretype end group for non-group")
4070		}
4071		if fieldNum <= 0 {
4072			return fmt.Errorf("proto: StateResponse: illegal tag %d (wire type %d)", fieldNum, wire)
4073		}
4074		switch fieldNum {
4075		case 1:
4076			if wireType != 2 {
4077				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
4078			}
4079			var stringLen uint64
4080			for shift := uint(0); ; shift += 7 {
4081				if shift >= 64 {
4082					return ErrIntOverflowShim
4083				}
4084				if iNdEx >= l {
4085					return io.ErrUnexpectedEOF
4086				}
4087				b := dAtA[iNdEx]
4088				iNdEx++
4089				stringLen |= uint64(b&0x7F) << shift
4090				if b < 0x80 {
4091					break
4092				}
4093			}
4094			intStringLen := int(stringLen)
4095			if intStringLen < 0 {
4096				return ErrInvalidLengthShim
4097			}
4098			postIndex := iNdEx + intStringLen
4099			if postIndex < 0 {
4100				return ErrInvalidLengthShim
4101			}
4102			if postIndex > l {
4103				return io.ErrUnexpectedEOF
4104			}
4105			m.ID = string(dAtA[iNdEx:postIndex])
4106			iNdEx = postIndex
4107		case 2:
4108			if wireType != 2 {
4109				return fmt.Errorf("proto: wrong wireType = %d for field Bundle", wireType)
4110			}
4111			var stringLen uint64
4112			for shift := uint(0); ; shift += 7 {
4113				if shift >= 64 {
4114					return ErrIntOverflowShim
4115				}
4116				if iNdEx >= l {
4117					return io.ErrUnexpectedEOF
4118				}
4119				b := dAtA[iNdEx]
4120				iNdEx++
4121				stringLen |= uint64(b&0x7F) << shift
4122				if b < 0x80 {
4123					break
4124				}
4125			}
4126			intStringLen := int(stringLen)
4127			if intStringLen < 0 {
4128				return ErrInvalidLengthShim
4129			}
4130			postIndex := iNdEx + intStringLen
4131			if postIndex < 0 {
4132				return ErrInvalidLengthShim
4133			}
4134			if postIndex > l {
4135				return io.ErrUnexpectedEOF
4136			}
4137			m.Bundle = string(dAtA[iNdEx:postIndex])
4138			iNdEx = postIndex
4139		case 3:
4140			if wireType != 0 {
4141				return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType)
4142			}
4143			m.Pid = 0
4144			for shift := uint(0); ; shift += 7 {
4145				if shift >= 64 {
4146					return ErrIntOverflowShim
4147				}
4148				if iNdEx >= l {
4149					return io.ErrUnexpectedEOF
4150				}
4151				b := dAtA[iNdEx]
4152				iNdEx++
4153				m.Pid |= uint32(b&0x7F) << shift
4154				if b < 0x80 {
4155					break
4156				}
4157			}
4158		case 4:
4159			if wireType != 0 {
4160				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
4161			}
4162			m.Status = 0
4163			for shift := uint(0); ; shift += 7 {
4164				if shift >= 64 {
4165					return ErrIntOverflowShim
4166				}
4167				if iNdEx >= l {
4168					return io.ErrUnexpectedEOF
4169				}
4170				b := dAtA[iNdEx]
4171				iNdEx++
4172				m.Status |= task.Status(b&0x7F) << shift
4173				if b < 0x80 {
4174					break
4175				}
4176			}
4177		case 5:
4178			if wireType != 2 {
4179				return fmt.Errorf("proto: wrong wireType = %d for field Stdin", wireType)
4180			}
4181			var stringLen uint64
4182			for shift := uint(0); ; shift += 7 {
4183				if shift >= 64 {
4184					return ErrIntOverflowShim
4185				}
4186				if iNdEx >= l {
4187					return io.ErrUnexpectedEOF
4188				}
4189				b := dAtA[iNdEx]
4190				iNdEx++
4191				stringLen |= uint64(b&0x7F) << shift
4192				if b < 0x80 {
4193					break
4194				}
4195			}
4196			intStringLen := int(stringLen)
4197			if intStringLen < 0 {
4198				return ErrInvalidLengthShim
4199			}
4200			postIndex := iNdEx + intStringLen
4201			if postIndex < 0 {
4202				return ErrInvalidLengthShim
4203			}
4204			if postIndex > l {
4205				return io.ErrUnexpectedEOF
4206			}
4207			m.Stdin = string(dAtA[iNdEx:postIndex])
4208			iNdEx = postIndex
4209		case 6:
4210			if wireType != 2 {
4211				return fmt.Errorf("proto: wrong wireType = %d for field Stdout", wireType)
4212			}
4213			var stringLen uint64
4214			for shift := uint(0); ; shift += 7 {
4215				if shift >= 64 {
4216					return ErrIntOverflowShim
4217				}
4218				if iNdEx >= l {
4219					return io.ErrUnexpectedEOF
4220				}
4221				b := dAtA[iNdEx]
4222				iNdEx++
4223				stringLen |= uint64(b&0x7F) << shift
4224				if b < 0x80 {
4225					break
4226				}
4227			}
4228			intStringLen := int(stringLen)
4229			if intStringLen < 0 {
4230				return ErrInvalidLengthShim
4231			}
4232			postIndex := iNdEx + intStringLen
4233			if postIndex < 0 {
4234				return ErrInvalidLengthShim
4235			}
4236			if postIndex > l {
4237				return io.ErrUnexpectedEOF
4238			}
4239			m.Stdout = string(dAtA[iNdEx:postIndex])
4240			iNdEx = postIndex
4241		case 7:
4242			if wireType != 2 {
4243				return fmt.Errorf("proto: wrong wireType = %d for field Stderr", wireType)
4244			}
4245			var stringLen uint64
4246			for shift := uint(0); ; shift += 7 {
4247				if shift >= 64 {
4248					return ErrIntOverflowShim
4249				}
4250				if iNdEx >= l {
4251					return io.ErrUnexpectedEOF
4252				}
4253				b := dAtA[iNdEx]
4254				iNdEx++
4255				stringLen |= uint64(b&0x7F) << shift
4256				if b < 0x80 {
4257					break
4258				}
4259			}
4260			intStringLen := int(stringLen)
4261			if intStringLen < 0 {
4262				return ErrInvalidLengthShim
4263			}
4264			postIndex := iNdEx + intStringLen
4265			if postIndex < 0 {
4266				return ErrInvalidLengthShim
4267			}
4268			if postIndex > l {
4269				return io.ErrUnexpectedEOF
4270			}
4271			m.Stderr = string(dAtA[iNdEx:postIndex])
4272			iNdEx = postIndex
4273		case 8:
4274			if wireType != 0 {
4275				return fmt.Errorf("proto: wrong wireType = %d for field Terminal", wireType)
4276			}
4277			var v int
4278			for shift := uint(0); ; shift += 7 {
4279				if shift >= 64 {
4280					return ErrIntOverflowShim
4281				}
4282				if iNdEx >= l {
4283					return io.ErrUnexpectedEOF
4284				}
4285				b := dAtA[iNdEx]
4286				iNdEx++
4287				v |= int(b&0x7F) << shift
4288				if b < 0x80 {
4289					break
4290				}
4291			}
4292			m.Terminal = bool(v != 0)
4293		case 9:
4294			if wireType != 0 {
4295				return fmt.Errorf("proto: wrong wireType = %d for field ExitStatus", wireType)
4296			}
4297			m.ExitStatus = 0
4298			for shift := uint(0); ; shift += 7 {
4299				if shift >= 64 {
4300					return ErrIntOverflowShim
4301				}
4302				if iNdEx >= l {
4303					return io.ErrUnexpectedEOF
4304				}
4305				b := dAtA[iNdEx]
4306				iNdEx++
4307				m.ExitStatus |= uint32(b&0x7F) << shift
4308				if b < 0x80 {
4309					break
4310				}
4311			}
4312		case 10:
4313			if wireType != 2 {
4314				return fmt.Errorf("proto: wrong wireType = %d for field ExitedAt", wireType)
4315			}
4316			var msglen int
4317			for shift := uint(0); ; shift += 7 {
4318				if shift >= 64 {
4319					return ErrIntOverflowShim
4320				}
4321				if iNdEx >= l {
4322					return io.ErrUnexpectedEOF
4323				}
4324				b := dAtA[iNdEx]
4325				iNdEx++
4326				msglen |= int(b&0x7F) << shift
4327				if b < 0x80 {
4328					break
4329				}
4330			}
4331			if msglen < 0 {
4332				return ErrInvalidLengthShim
4333			}
4334			postIndex := iNdEx + msglen
4335			if postIndex < 0 {
4336				return ErrInvalidLengthShim
4337			}
4338			if postIndex > l {
4339				return io.ErrUnexpectedEOF
4340			}
4341			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.ExitedAt, dAtA[iNdEx:postIndex]); err != nil {
4342				return err
4343			}
4344			iNdEx = postIndex
4345		default:
4346			iNdEx = preIndex
4347			skippy, err := skipShim(dAtA[iNdEx:])
4348			if err != nil {
4349				return err
4350			}
4351			if (skippy < 0) || (iNdEx+skippy) < 0 {
4352				return ErrInvalidLengthShim
4353			}
4354			if (iNdEx + skippy) > l {
4355				return io.ErrUnexpectedEOF
4356			}
4357			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
4358			iNdEx += skippy
4359		}
4360	}
4361
4362	if iNdEx > l {
4363		return io.ErrUnexpectedEOF
4364	}
4365	return nil
4366}
4367func (m *KillRequest) Unmarshal(dAtA []byte) error {
4368	l := len(dAtA)
4369	iNdEx := 0
4370	for iNdEx < l {
4371		preIndex := iNdEx
4372		var wire uint64
4373		for shift := uint(0); ; shift += 7 {
4374			if shift >= 64 {
4375				return ErrIntOverflowShim
4376			}
4377			if iNdEx >= l {
4378				return io.ErrUnexpectedEOF
4379			}
4380			b := dAtA[iNdEx]
4381			iNdEx++
4382			wire |= uint64(b&0x7F) << shift
4383			if b < 0x80 {
4384				break
4385			}
4386		}
4387		fieldNum := int32(wire >> 3)
4388		wireType := int(wire & 0x7)
4389		if wireType == 4 {
4390			return fmt.Errorf("proto: KillRequest: wiretype end group for non-group")
4391		}
4392		if fieldNum <= 0 {
4393			return fmt.Errorf("proto: KillRequest: illegal tag %d (wire type %d)", fieldNum, wire)
4394		}
4395		switch fieldNum {
4396		case 1:
4397			if wireType != 2 {
4398				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
4399			}
4400			var stringLen uint64
4401			for shift := uint(0); ; shift += 7 {
4402				if shift >= 64 {
4403					return ErrIntOverflowShim
4404				}
4405				if iNdEx >= l {
4406					return io.ErrUnexpectedEOF
4407				}
4408				b := dAtA[iNdEx]
4409				iNdEx++
4410				stringLen |= uint64(b&0x7F) << shift
4411				if b < 0x80 {
4412					break
4413				}
4414			}
4415			intStringLen := int(stringLen)
4416			if intStringLen < 0 {
4417				return ErrInvalidLengthShim
4418			}
4419			postIndex := iNdEx + intStringLen
4420			if postIndex < 0 {
4421				return ErrInvalidLengthShim
4422			}
4423			if postIndex > l {
4424				return io.ErrUnexpectedEOF
4425			}
4426			m.ID = string(dAtA[iNdEx:postIndex])
4427			iNdEx = postIndex
4428		case 2:
4429			if wireType != 0 {
4430				return fmt.Errorf("proto: wrong wireType = %d for field Signal", wireType)
4431			}
4432			m.Signal = 0
4433			for shift := uint(0); ; shift += 7 {
4434				if shift >= 64 {
4435					return ErrIntOverflowShim
4436				}
4437				if iNdEx >= l {
4438					return io.ErrUnexpectedEOF
4439				}
4440				b := dAtA[iNdEx]
4441				iNdEx++
4442				m.Signal |= uint32(b&0x7F) << shift
4443				if b < 0x80 {
4444					break
4445				}
4446			}
4447		case 3:
4448			if wireType != 0 {
4449				return fmt.Errorf("proto: wrong wireType = %d for field All", wireType)
4450			}
4451			var v int
4452			for shift := uint(0); ; shift += 7 {
4453				if shift >= 64 {
4454					return ErrIntOverflowShim
4455				}
4456				if iNdEx >= l {
4457					return io.ErrUnexpectedEOF
4458				}
4459				b := dAtA[iNdEx]
4460				iNdEx++
4461				v |= int(b&0x7F) << shift
4462				if b < 0x80 {
4463					break
4464				}
4465			}
4466			m.All = bool(v != 0)
4467		default:
4468			iNdEx = preIndex
4469			skippy, err := skipShim(dAtA[iNdEx:])
4470			if err != nil {
4471				return err
4472			}
4473			if (skippy < 0) || (iNdEx+skippy) < 0 {
4474				return ErrInvalidLengthShim
4475			}
4476			if (iNdEx + skippy) > l {
4477				return io.ErrUnexpectedEOF
4478			}
4479			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
4480			iNdEx += skippy
4481		}
4482	}
4483
4484	if iNdEx > l {
4485		return io.ErrUnexpectedEOF
4486	}
4487	return nil
4488}
4489func (m *CloseIORequest) Unmarshal(dAtA []byte) error {
4490	l := len(dAtA)
4491	iNdEx := 0
4492	for iNdEx < l {
4493		preIndex := iNdEx
4494		var wire uint64
4495		for shift := uint(0); ; shift += 7 {
4496			if shift >= 64 {
4497				return ErrIntOverflowShim
4498			}
4499			if iNdEx >= l {
4500				return io.ErrUnexpectedEOF
4501			}
4502			b := dAtA[iNdEx]
4503			iNdEx++
4504			wire |= uint64(b&0x7F) << shift
4505			if b < 0x80 {
4506				break
4507			}
4508		}
4509		fieldNum := int32(wire >> 3)
4510		wireType := int(wire & 0x7)
4511		if wireType == 4 {
4512			return fmt.Errorf("proto: CloseIORequest: wiretype end group for non-group")
4513		}
4514		if fieldNum <= 0 {
4515			return fmt.Errorf("proto: CloseIORequest: illegal tag %d (wire type %d)", fieldNum, wire)
4516		}
4517		switch fieldNum {
4518		case 1:
4519			if wireType != 2 {
4520				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
4521			}
4522			var stringLen uint64
4523			for shift := uint(0); ; shift += 7 {
4524				if shift >= 64 {
4525					return ErrIntOverflowShim
4526				}
4527				if iNdEx >= l {
4528					return io.ErrUnexpectedEOF
4529				}
4530				b := dAtA[iNdEx]
4531				iNdEx++
4532				stringLen |= uint64(b&0x7F) << shift
4533				if b < 0x80 {
4534					break
4535				}
4536			}
4537			intStringLen := int(stringLen)
4538			if intStringLen < 0 {
4539				return ErrInvalidLengthShim
4540			}
4541			postIndex := iNdEx + intStringLen
4542			if postIndex < 0 {
4543				return ErrInvalidLengthShim
4544			}
4545			if postIndex > l {
4546				return io.ErrUnexpectedEOF
4547			}
4548			m.ID = string(dAtA[iNdEx:postIndex])
4549			iNdEx = postIndex
4550		case 2:
4551			if wireType != 0 {
4552				return fmt.Errorf("proto: wrong wireType = %d for field Stdin", wireType)
4553			}
4554			var v int
4555			for shift := uint(0); ; shift += 7 {
4556				if shift >= 64 {
4557					return ErrIntOverflowShim
4558				}
4559				if iNdEx >= l {
4560					return io.ErrUnexpectedEOF
4561				}
4562				b := dAtA[iNdEx]
4563				iNdEx++
4564				v |= int(b&0x7F) << shift
4565				if b < 0x80 {
4566					break
4567				}
4568			}
4569			m.Stdin = bool(v != 0)
4570		default:
4571			iNdEx = preIndex
4572			skippy, err := skipShim(dAtA[iNdEx:])
4573			if err != nil {
4574				return err
4575			}
4576			if (skippy < 0) || (iNdEx+skippy) < 0 {
4577				return ErrInvalidLengthShim
4578			}
4579			if (iNdEx + skippy) > l {
4580				return io.ErrUnexpectedEOF
4581			}
4582			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
4583			iNdEx += skippy
4584		}
4585	}
4586
4587	if iNdEx > l {
4588		return io.ErrUnexpectedEOF
4589	}
4590	return nil
4591}
4592func (m *ListPidsRequest) Unmarshal(dAtA []byte) error {
4593	l := len(dAtA)
4594	iNdEx := 0
4595	for iNdEx < l {
4596		preIndex := iNdEx
4597		var wire uint64
4598		for shift := uint(0); ; shift += 7 {
4599			if shift >= 64 {
4600				return ErrIntOverflowShim
4601			}
4602			if iNdEx >= l {
4603				return io.ErrUnexpectedEOF
4604			}
4605			b := dAtA[iNdEx]
4606			iNdEx++
4607			wire |= uint64(b&0x7F) << shift
4608			if b < 0x80 {
4609				break
4610			}
4611		}
4612		fieldNum := int32(wire >> 3)
4613		wireType := int(wire & 0x7)
4614		if wireType == 4 {
4615			return fmt.Errorf("proto: ListPidsRequest: wiretype end group for non-group")
4616		}
4617		if fieldNum <= 0 {
4618			return fmt.Errorf("proto: ListPidsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
4619		}
4620		switch fieldNum {
4621		case 1:
4622			if wireType != 2 {
4623				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
4624			}
4625			var stringLen uint64
4626			for shift := uint(0); ; shift += 7 {
4627				if shift >= 64 {
4628					return ErrIntOverflowShim
4629				}
4630				if iNdEx >= l {
4631					return io.ErrUnexpectedEOF
4632				}
4633				b := dAtA[iNdEx]
4634				iNdEx++
4635				stringLen |= uint64(b&0x7F) << shift
4636				if b < 0x80 {
4637					break
4638				}
4639			}
4640			intStringLen := int(stringLen)
4641			if intStringLen < 0 {
4642				return ErrInvalidLengthShim
4643			}
4644			postIndex := iNdEx + intStringLen
4645			if postIndex < 0 {
4646				return ErrInvalidLengthShim
4647			}
4648			if postIndex > l {
4649				return io.ErrUnexpectedEOF
4650			}
4651			m.ID = string(dAtA[iNdEx:postIndex])
4652			iNdEx = postIndex
4653		default:
4654			iNdEx = preIndex
4655			skippy, err := skipShim(dAtA[iNdEx:])
4656			if err != nil {
4657				return err
4658			}
4659			if (skippy < 0) || (iNdEx+skippy) < 0 {
4660				return ErrInvalidLengthShim
4661			}
4662			if (iNdEx + skippy) > l {
4663				return io.ErrUnexpectedEOF
4664			}
4665			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
4666			iNdEx += skippy
4667		}
4668	}
4669
4670	if iNdEx > l {
4671		return io.ErrUnexpectedEOF
4672	}
4673	return nil
4674}
4675func (m *ListPidsResponse) Unmarshal(dAtA []byte) error {
4676	l := len(dAtA)
4677	iNdEx := 0
4678	for iNdEx < l {
4679		preIndex := iNdEx
4680		var wire uint64
4681		for shift := uint(0); ; shift += 7 {
4682			if shift >= 64 {
4683				return ErrIntOverflowShim
4684			}
4685			if iNdEx >= l {
4686				return io.ErrUnexpectedEOF
4687			}
4688			b := dAtA[iNdEx]
4689			iNdEx++
4690			wire |= uint64(b&0x7F) << shift
4691			if b < 0x80 {
4692				break
4693			}
4694		}
4695		fieldNum := int32(wire >> 3)
4696		wireType := int(wire & 0x7)
4697		if wireType == 4 {
4698			return fmt.Errorf("proto: ListPidsResponse: wiretype end group for non-group")
4699		}
4700		if fieldNum <= 0 {
4701			return fmt.Errorf("proto: ListPidsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
4702		}
4703		switch fieldNum {
4704		case 1:
4705			if wireType != 2 {
4706				return fmt.Errorf("proto: wrong wireType = %d for field Processes", wireType)
4707			}
4708			var msglen int
4709			for shift := uint(0); ; shift += 7 {
4710				if shift >= 64 {
4711					return ErrIntOverflowShim
4712				}
4713				if iNdEx >= l {
4714					return io.ErrUnexpectedEOF
4715				}
4716				b := dAtA[iNdEx]
4717				iNdEx++
4718				msglen |= int(b&0x7F) << shift
4719				if b < 0x80 {
4720					break
4721				}
4722			}
4723			if msglen < 0 {
4724				return ErrInvalidLengthShim
4725			}
4726			postIndex := iNdEx + msglen
4727			if postIndex < 0 {
4728				return ErrInvalidLengthShim
4729			}
4730			if postIndex > l {
4731				return io.ErrUnexpectedEOF
4732			}
4733			m.Processes = append(m.Processes, &task.ProcessInfo{})
4734			if err := m.Processes[len(m.Processes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4735				return err
4736			}
4737			iNdEx = postIndex
4738		default:
4739			iNdEx = preIndex
4740			skippy, err := skipShim(dAtA[iNdEx:])
4741			if err != nil {
4742				return err
4743			}
4744			if (skippy < 0) || (iNdEx+skippy) < 0 {
4745				return ErrInvalidLengthShim
4746			}
4747			if (iNdEx + skippy) > l {
4748				return io.ErrUnexpectedEOF
4749			}
4750			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
4751			iNdEx += skippy
4752		}
4753	}
4754
4755	if iNdEx > l {
4756		return io.ErrUnexpectedEOF
4757	}
4758	return nil
4759}
4760func (m *CheckpointTaskRequest) Unmarshal(dAtA []byte) error {
4761	l := len(dAtA)
4762	iNdEx := 0
4763	for iNdEx < l {
4764		preIndex := iNdEx
4765		var wire uint64
4766		for shift := uint(0); ; shift += 7 {
4767			if shift >= 64 {
4768				return ErrIntOverflowShim
4769			}
4770			if iNdEx >= l {
4771				return io.ErrUnexpectedEOF
4772			}
4773			b := dAtA[iNdEx]
4774			iNdEx++
4775			wire |= uint64(b&0x7F) << shift
4776			if b < 0x80 {
4777				break
4778			}
4779		}
4780		fieldNum := int32(wire >> 3)
4781		wireType := int(wire & 0x7)
4782		if wireType == 4 {
4783			return fmt.Errorf("proto: CheckpointTaskRequest: wiretype end group for non-group")
4784		}
4785		if fieldNum <= 0 {
4786			return fmt.Errorf("proto: CheckpointTaskRequest: illegal tag %d (wire type %d)", fieldNum, wire)
4787		}
4788		switch fieldNum {
4789		case 1:
4790			if wireType != 2 {
4791				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
4792			}
4793			var stringLen uint64
4794			for shift := uint(0); ; shift += 7 {
4795				if shift >= 64 {
4796					return ErrIntOverflowShim
4797				}
4798				if iNdEx >= l {
4799					return io.ErrUnexpectedEOF
4800				}
4801				b := dAtA[iNdEx]
4802				iNdEx++
4803				stringLen |= uint64(b&0x7F) << shift
4804				if b < 0x80 {
4805					break
4806				}
4807			}
4808			intStringLen := int(stringLen)
4809			if intStringLen < 0 {
4810				return ErrInvalidLengthShim
4811			}
4812			postIndex := iNdEx + intStringLen
4813			if postIndex < 0 {
4814				return ErrInvalidLengthShim
4815			}
4816			if postIndex > l {
4817				return io.ErrUnexpectedEOF
4818			}
4819			m.Path = string(dAtA[iNdEx:postIndex])
4820			iNdEx = postIndex
4821		case 2:
4822			if wireType != 2 {
4823				return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
4824			}
4825			var msglen int
4826			for shift := uint(0); ; shift += 7 {
4827				if shift >= 64 {
4828					return ErrIntOverflowShim
4829				}
4830				if iNdEx >= l {
4831					return io.ErrUnexpectedEOF
4832				}
4833				b := dAtA[iNdEx]
4834				iNdEx++
4835				msglen |= int(b&0x7F) << shift
4836				if b < 0x80 {
4837					break
4838				}
4839			}
4840			if msglen < 0 {
4841				return ErrInvalidLengthShim
4842			}
4843			postIndex := iNdEx + msglen
4844			if postIndex < 0 {
4845				return ErrInvalidLengthShim
4846			}
4847			if postIndex > l {
4848				return io.ErrUnexpectedEOF
4849			}
4850			if m.Options == nil {
4851				m.Options = &types1.Any{}
4852			}
4853			if err := m.Options.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4854				return err
4855			}
4856			iNdEx = postIndex
4857		default:
4858			iNdEx = preIndex
4859			skippy, err := skipShim(dAtA[iNdEx:])
4860			if err != nil {
4861				return err
4862			}
4863			if (skippy < 0) || (iNdEx+skippy) < 0 {
4864				return ErrInvalidLengthShim
4865			}
4866			if (iNdEx + skippy) > l {
4867				return io.ErrUnexpectedEOF
4868			}
4869			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
4870			iNdEx += skippy
4871		}
4872	}
4873
4874	if iNdEx > l {
4875		return io.ErrUnexpectedEOF
4876	}
4877	return nil
4878}
4879func (m *ShimInfoResponse) Unmarshal(dAtA []byte) error {
4880	l := len(dAtA)
4881	iNdEx := 0
4882	for iNdEx < l {
4883		preIndex := iNdEx
4884		var wire uint64
4885		for shift := uint(0); ; shift += 7 {
4886			if shift >= 64 {
4887				return ErrIntOverflowShim
4888			}
4889			if iNdEx >= l {
4890				return io.ErrUnexpectedEOF
4891			}
4892			b := dAtA[iNdEx]
4893			iNdEx++
4894			wire |= uint64(b&0x7F) << shift
4895			if b < 0x80 {
4896				break
4897			}
4898		}
4899		fieldNum := int32(wire >> 3)
4900		wireType := int(wire & 0x7)
4901		if wireType == 4 {
4902			return fmt.Errorf("proto: ShimInfoResponse: wiretype end group for non-group")
4903		}
4904		if fieldNum <= 0 {
4905			return fmt.Errorf("proto: ShimInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire)
4906		}
4907		switch fieldNum {
4908		case 1:
4909			if wireType != 0 {
4910				return fmt.Errorf("proto: wrong wireType = %d for field ShimPid", wireType)
4911			}
4912			m.ShimPid = 0
4913			for shift := uint(0); ; shift += 7 {
4914				if shift >= 64 {
4915					return ErrIntOverflowShim
4916				}
4917				if iNdEx >= l {
4918					return io.ErrUnexpectedEOF
4919				}
4920				b := dAtA[iNdEx]
4921				iNdEx++
4922				m.ShimPid |= uint32(b&0x7F) << shift
4923				if b < 0x80 {
4924					break
4925				}
4926			}
4927		default:
4928			iNdEx = preIndex
4929			skippy, err := skipShim(dAtA[iNdEx:])
4930			if err != nil {
4931				return err
4932			}
4933			if (skippy < 0) || (iNdEx+skippy) < 0 {
4934				return ErrInvalidLengthShim
4935			}
4936			if (iNdEx + skippy) > l {
4937				return io.ErrUnexpectedEOF
4938			}
4939			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
4940			iNdEx += skippy
4941		}
4942	}
4943
4944	if iNdEx > l {
4945		return io.ErrUnexpectedEOF
4946	}
4947	return nil
4948}
4949func (m *UpdateTaskRequest) Unmarshal(dAtA []byte) error {
4950	l := len(dAtA)
4951	iNdEx := 0
4952	for iNdEx < l {
4953		preIndex := iNdEx
4954		var wire uint64
4955		for shift := uint(0); ; shift += 7 {
4956			if shift >= 64 {
4957				return ErrIntOverflowShim
4958			}
4959			if iNdEx >= l {
4960				return io.ErrUnexpectedEOF
4961			}
4962			b := dAtA[iNdEx]
4963			iNdEx++
4964			wire |= uint64(b&0x7F) << shift
4965			if b < 0x80 {
4966				break
4967			}
4968		}
4969		fieldNum := int32(wire >> 3)
4970		wireType := int(wire & 0x7)
4971		if wireType == 4 {
4972			return fmt.Errorf("proto: UpdateTaskRequest: wiretype end group for non-group")
4973		}
4974		if fieldNum <= 0 {
4975			return fmt.Errorf("proto: UpdateTaskRequest: illegal tag %d (wire type %d)", fieldNum, wire)
4976		}
4977		switch fieldNum {
4978		case 1:
4979			if wireType != 2 {
4980				return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType)
4981			}
4982			var msglen int
4983			for shift := uint(0); ; shift += 7 {
4984				if shift >= 64 {
4985					return ErrIntOverflowShim
4986				}
4987				if iNdEx >= l {
4988					return io.ErrUnexpectedEOF
4989				}
4990				b := dAtA[iNdEx]
4991				iNdEx++
4992				msglen |= int(b&0x7F) << shift
4993				if b < 0x80 {
4994					break
4995				}
4996			}
4997			if msglen < 0 {
4998				return ErrInvalidLengthShim
4999			}
5000			postIndex := iNdEx + msglen
5001			if postIndex < 0 {
5002				return ErrInvalidLengthShim
5003			}
5004			if postIndex > l {
5005				return io.ErrUnexpectedEOF
5006			}
5007			if m.Resources == nil {
5008				m.Resources = &types1.Any{}
5009			}
5010			if err := m.Resources.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5011				return err
5012			}
5013			iNdEx = postIndex
5014		default:
5015			iNdEx = preIndex
5016			skippy, err := skipShim(dAtA[iNdEx:])
5017			if err != nil {
5018				return err
5019			}
5020			if (skippy < 0) || (iNdEx+skippy) < 0 {
5021				return ErrInvalidLengthShim
5022			}
5023			if (iNdEx + skippy) > l {
5024				return io.ErrUnexpectedEOF
5025			}
5026			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5027			iNdEx += skippy
5028		}
5029	}
5030
5031	if iNdEx > l {
5032		return io.ErrUnexpectedEOF
5033	}
5034	return nil
5035}
5036func (m *StartRequest) Unmarshal(dAtA []byte) error {
5037	l := len(dAtA)
5038	iNdEx := 0
5039	for iNdEx < l {
5040		preIndex := iNdEx
5041		var wire uint64
5042		for shift := uint(0); ; shift += 7 {
5043			if shift >= 64 {
5044				return ErrIntOverflowShim
5045			}
5046			if iNdEx >= l {
5047				return io.ErrUnexpectedEOF
5048			}
5049			b := dAtA[iNdEx]
5050			iNdEx++
5051			wire |= uint64(b&0x7F) << shift
5052			if b < 0x80 {
5053				break
5054			}
5055		}
5056		fieldNum := int32(wire >> 3)
5057		wireType := int(wire & 0x7)
5058		if wireType == 4 {
5059			return fmt.Errorf("proto: StartRequest: wiretype end group for non-group")
5060		}
5061		if fieldNum <= 0 {
5062			return fmt.Errorf("proto: StartRequest: illegal tag %d (wire type %d)", fieldNum, wire)
5063		}
5064		switch fieldNum {
5065		case 1:
5066			if wireType != 2 {
5067				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
5068			}
5069			var stringLen uint64
5070			for shift := uint(0); ; shift += 7 {
5071				if shift >= 64 {
5072					return ErrIntOverflowShim
5073				}
5074				if iNdEx >= l {
5075					return io.ErrUnexpectedEOF
5076				}
5077				b := dAtA[iNdEx]
5078				iNdEx++
5079				stringLen |= uint64(b&0x7F) << shift
5080				if b < 0x80 {
5081					break
5082				}
5083			}
5084			intStringLen := int(stringLen)
5085			if intStringLen < 0 {
5086				return ErrInvalidLengthShim
5087			}
5088			postIndex := iNdEx + intStringLen
5089			if postIndex < 0 {
5090				return ErrInvalidLengthShim
5091			}
5092			if postIndex > l {
5093				return io.ErrUnexpectedEOF
5094			}
5095			m.ID = string(dAtA[iNdEx:postIndex])
5096			iNdEx = postIndex
5097		default:
5098			iNdEx = preIndex
5099			skippy, err := skipShim(dAtA[iNdEx:])
5100			if err != nil {
5101				return err
5102			}
5103			if (skippy < 0) || (iNdEx+skippy) < 0 {
5104				return ErrInvalidLengthShim
5105			}
5106			if (iNdEx + skippy) > l {
5107				return io.ErrUnexpectedEOF
5108			}
5109			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5110			iNdEx += skippy
5111		}
5112	}
5113
5114	if iNdEx > l {
5115		return io.ErrUnexpectedEOF
5116	}
5117	return nil
5118}
5119func (m *StartResponse) Unmarshal(dAtA []byte) error {
5120	l := len(dAtA)
5121	iNdEx := 0
5122	for iNdEx < l {
5123		preIndex := iNdEx
5124		var wire uint64
5125		for shift := uint(0); ; shift += 7 {
5126			if shift >= 64 {
5127				return ErrIntOverflowShim
5128			}
5129			if iNdEx >= l {
5130				return io.ErrUnexpectedEOF
5131			}
5132			b := dAtA[iNdEx]
5133			iNdEx++
5134			wire |= uint64(b&0x7F) << shift
5135			if b < 0x80 {
5136				break
5137			}
5138		}
5139		fieldNum := int32(wire >> 3)
5140		wireType := int(wire & 0x7)
5141		if wireType == 4 {
5142			return fmt.Errorf("proto: StartResponse: wiretype end group for non-group")
5143		}
5144		if fieldNum <= 0 {
5145			return fmt.Errorf("proto: StartResponse: illegal tag %d (wire type %d)", fieldNum, wire)
5146		}
5147		switch fieldNum {
5148		case 1:
5149			if wireType != 2 {
5150				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
5151			}
5152			var stringLen uint64
5153			for shift := uint(0); ; shift += 7 {
5154				if shift >= 64 {
5155					return ErrIntOverflowShim
5156				}
5157				if iNdEx >= l {
5158					return io.ErrUnexpectedEOF
5159				}
5160				b := dAtA[iNdEx]
5161				iNdEx++
5162				stringLen |= uint64(b&0x7F) << shift
5163				if b < 0x80 {
5164					break
5165				}
5166			}
5167			intStringLen := int(stringLen)
5168			if intStringLen < 0 {
5169				return ErrInvalidLengthShim
5170			}
5171			postIndex := iNdEx + intStringLen
5172			if postIndex < 0 {
5173				return ErrInvalidLengthShim
5174			}
5175			if postIndex > l {
5176				return io.ErrUnexpectedEOF
5177			}
5178			m.ID = string(dAtA[iNdEx:postIndex])
5179			iNdEx = postIndex
5180		case 2:
5181			if wireType != 0 {
5182				return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType)
5183			}
5184			m.Pid = 0
5185			for shift := uint(0); ; shift += 7 {
5186				if shift >= 64 {
5187					return ErrIntOverflowShim
5188				}
5189				if iNdEx >= l {
5190					return io.ErrUnexpectedEOF
5191				}
5192				b := dAtA[iNdEx]
5193				iNdEx++
5194				m.Pid |= uint32(b&0x7F) << shift
5195				if b < 0x80 {
5196					break
5197				}
5198			}
5199		default:
5200			iNdEx = preIndex
5201			skippy, err := skipShim(dAtA[iNdEx:])
5202			if err != nil {
5203				return err
5204			}
5205			if (skippy < 0) || (iNdEx+skippy) < 0 {
5206				return ErrInvalidLengthShim
5207			}
5208			if (iNdEx + skippy) > l {
5209				return io.ErrUnexpectedEOF
5210			}
5211			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5212			iNdEx += skippy
5213		}
5214	}
5215
5216	if iNdEx > l {
5217		return io.ErrUnexpectedEOF
5218	}
5219	return nil
5220}
5221func (m *WaitRequest) Unmarshal(dAtA []byte) error {
5222	l := len(dAtA)
5223	iNdEx := 0
5224	for iNdEx < l {
5225		preIndex := iNdEx
5226		var wire uint64
5227		for shift := uint(0); ; shift += 7 {
5228			if shift >= 64 {
5229				return ErrIntOverflowShim
5230			}
5231			if iNdEx >= l {
5232				return io.ErrUnexpectedEOF
5233			}
5234			b := dAtA[iNdEx]
5235			iNdEx++
5236			wire |= uint64(b&0x7F) << shift
5237			if b < 0x80 {
5238				break
5239			}
5240		}
5241		fieldNum := int32(wire >> 3)
5242		wireType := int(wire & 0x7)
5243		if wireType == 4 {
5244			return fmt.Errorf("proto: WaitRequest: wiretype end group for non-group")
5245		}
5246		if fieldNum <= 0 {
5247			return fmt.Errorf("proto: WaitRequest: illegal tag %d (wire type %d)", fieldNum, wire)
5248		}
5249		switch fieldNum {
5250		case 1:
5251			if wireType != 2 {
5252				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
5253			}
5254			var stringLen uint64
5255			for shift := uint(0); ; shift += 7 {
5256				if shift >= 64 {
5257					return ErrIntOverflowShim
5258				}
5259				if iNdEx >= l {
5260					return io.ErrUnexpectedEOF
5261				}
5262				b := dAtA[iNdEx]
5263				iNdEx++
5264				stringLen |= uint64(b&0x7F) << shift
5265				if b < 0x80 {
5266					break
5267				}
5268			}
5269			intStringLen := int(stringLen)
5270			if intStringLen < 0 {
5271				return ErrInvalidLengthShim
5272			}
5273			postIndex := iNdEx + intStringLen
5274			if postIndex < 0 {
5275				return ErrInvalidLengthShim
5276			}
5277			if postIndex > l {
5278				return io.ErrUnexpectedEOF
5279			}
5280			m.ID = string(dAtA[iNdEx:postIndex])
5281			iNdEx = postIndex
5282		default:
5283			iNdEx = preIndex
5284			skippy, err := skipShim(dAtA[iNdEx:])
5285			if err != nil {
5286				return err
5287			}
5288			if (skippy < 0) || (iNdEx+skippy) < 0 {
5289				return ErrInvalidLengthShim
5290			}
5291			if (iNdEx + skippy) > l {
5292				return io.ErrUnexpectedEOF
5293			}
5294			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5295			iNdEx += skippy
5296		}
5297	}
5298
5299	if iNdEx > l {
5300		return io.ErrUnexpectedEOF
5301	}
5302	return nil
5303}
5304func (m *WaitResponse) Unmarshal(dAtA []byte) error {
5305	l := len(dAtA)
5306	iNdEx := 0
5307	for iNdEx < l {
5308		preIndex := iNdEx
5309		var wire uint64
5310		for shift := uint(0); ; shift += 7 {
5311			if shift >= 64 {
5312				return ErrIntOverflowShim
5313			}
5314			if iNdEx >= l {
5315				return io.ErrUnexpectedEOF
5316			}
5317			b := dAtA[iNdEx]
5318			iNdEx++
5319			wire |= uint64(b&0x7F) << shift
5320			if b < 0x80 {
5321				break
5322			}
5323		}
5324		fieldNum := int32(wire >> 3)
5325		wireType := int(wire & 0x7)
5326		if wireType == 4 {
5327			return fmt.Errorf("proto: WaitResponse: wiretype end group for non-group")
5328		}
5329		if fieldNum <= 0 {
5330			return fmt.Errorf("proto: WaitResponse: illegal tag %d (wire type %d)", fieldNum, wire)
5331		}
5332		switch fieldNum {
5333		case 1:
5334			if wireType != 0 {
5335				return fmt.Errorf("proto: wrong wireType = %d for field ExitStatus", wireType)
5336			}
5337			m.ExitStatus = 0
5338			for shift := uint(0); ; shift += 7 {
5339				if shift >= 64 {
5340					return ErrIntOverflowShim
5341				}
5342				if iNdEx >= l {
5343					return io.ErrUnexpectedEOF
5344				}
5345				b := dAtA[iNdEx]
5346				iNdEx++
5347				m.ExitStatus |= uint32(b&0x7F) << shift
5348				if b < 0x80 {
5349					break
5350				}
5351			}
5352		case 2:
5353			if wireType != 2 {
5354				return fmt.Errorf("proto: wrong wireType = %d for field ExitedAt", wireType)
5355			}
5356			var msglen int
5357			for shift := uint(0); ; shift += 7 {
5358				if shift >= 64 {
5359					return ErrIntOverflowShim
5360				}
5361				if iNdEx >= l {
5362					return io.ErrUnexpectedEOF
5363				}
5364				b := dAtA[iNdEx]
5365				iNdEx++
5366				msglen |= int(b&0x7F) << shift
5367				if b < 0x80 {
5368					break
5369				}
5370			}
5371			if msglen < 0 {
5372				return ErrInvalidLengthShim
5373			}
5374			postIndex := iNdEx + msglen
5375			if postIndex < 0 {
5376				return ErrInvalidLengthShim
5377			}
5378			if postIndex > l {
5379				return io.ErrUnexpectedEOF
5380			}
5381			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.ExitedAt, dAtA[iNdEx:postIndex]); err != nil {
5382				return err
5383			}
5384			iNdEx = postIndex
5385		default:
5386			iNdEx = preIndex
5387			skippy, err := skipShim(dAtA[iNdEx:])
5388			if err != nil {
5389				return err
5390			}
5391			if (skippy < 0) || (iNdEx+skippy) < 0 {
5392				return ErrInvalidLengthShim
5393			}
5394			if (iNdEx + skippy) > l {
5395				return io.ErrUnexpectedEOF
5396			}
5397			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5398			iNdEx += skippy
5399		}
5400	}
5401
5402	if iNdEx > l {
5403		return io.ErrUnexpectedEOF
5404	}
5405	return nil
5406}
5407func skipShim(dAtA []byte) (n int, err error) {
5408	l := len(dAtA)
5409	iNdEx := 0
5410	depth := 0
5411	for iNdEx < l {
5412		var wire uint64
5413		for shift := uint(0); ; shift += 7 {
5414			if shift >= 64 {
5415				return 0, ErrIntOverflowShim
5416			}
5417			if iNdEx >= l {
5418				return 0, io.ErrUnexpectedEOF
5419			}
5420			b := dAtA[iNdEx]
5421			iNdEx++
5422			wire |= (uint64(b) & 0x7F) << shift
5423			if b < 0x80 {
5424				break
5425			}
5426		}
5427		wireType := int(wire & 0x7)
5428		switch wireType {
5429		case 0:
5430			for shift := uint(0); ; shift += 7 {
5431				if shift >= 64 {
5432					return 0, ErrIntOverflowShim
5433				}
5434				if iNdEx >= l {
5435					return 0, io.ErrUnexpectedEOF
5436				}
5437				iNdEx++
5438				if dAtA[iNdEx-1] < 0x80 {
5439					break
5440				}
5441			}
5442		case 1:
5443			iNdEx += 8
5444		case 2:
5445			var length int
5446			for shift := uint(0); ; shift += 7 {
5447				if shift >= 64 {
5448					return 0, ErrIntOverflowShim
5449				}
5450				if iNdEx >= l {
5451					return 0, io.ErrUnexpectedEOF
5452				}
5453				b := dAtA[iNdEx]
5454				iNdEx++
5455				length |= (int(b) & 0x7F) << shift
5456				if b < 0x80 {
5457					break
5458				}
5459			}
5460			if length < 0 {
5461				return 0, ErrInvalidLengthShim
5462			}
5463			iNdEx += length
5464		case 3:
5465			depth++
5466		case 4:
5467			if depth == 0 {
5468				return 0, ErrUnexpectedEndOfGroupShim
5469			}
5470			depth--
5471		case 5:
5472			iNdEx += 4
5473		default:
5474			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
5475		}
5476		if iNdEx < 0 {
5477			return 0, ErrInvalidLengthShim
5478		}
5479		if depth == 0 {
5480			return iNdEx, nil
5481		}
5482	}
5483	return 0, io.ErrUnexpectedEOF
5484}
5485
5486var (
5487	ErrInvalidLengthShim        = fmt.Errorf("proto: negative length found during unmarshaling")
5488	ErrIntOverflowShim          = fmt.Errorf("proto: integer overflow")
5489	ErrUnexpectedEndOfGroupShim = fmt.Errorf("proto: unexpected end of group")
5490)
5491