From 8a36e1c6d1376a61855c5b2fdb51657ad1d5ad63 Mon Sep 17 00:00:00 2001 From: Stephen J Day Date: Thu, 1 Dec 2016 13:31:57 -0800 Subject: [PATCH] api: use correct generation helper Signed-off-by: Stephen J Day --- api/container/container.pb.go | 2303 ++++++++++++++++++--------------- api/container/gen.go | 2 +- api/registry/gen.go | 4 +- api/registry/registry.pb.go | 478 +++---- 4 files changed, 1485 insertions(+), 1302 deletions(-) diff --git a/api/container/container.pb.go b/api/container/container.pb.go index a82bf35cb..933cf2107 100644 --- a/api/container/container.pb.go +++ b/api/container/container.pb.go @@ -73,7 +73,9 @@ var _ = math.Inf // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. -const _ = proto.GoGoProtoPackageIsVersion1 +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package type Container struct { ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` @@ -128,7 +130,7 @@ func (*Mount) Descriptor() ([]byte, []int) { return fileDescriptorContainer, []i type User struct { Uid uint32 `protobuf:"varint,1,opt,name=uid,proto3" json:"uid,omitempty"` Gid uint32 `protobuf:"varint,2,opt,name=gid,proto3" json:"gid,omitempty"` - AdditionalGids []uint32 `protobuf:"varint,3,rep,name=additionalGids" json:"additionalGids,omitempty"` + AdditionalGids []uint32 `protobuf:"varint,3,rep,packed,name=additionalGids" json:"additionalGids,omitempty"` } func (m *User) Reset() { *m = User{} } @@ -831,11 +833,12 @@ func valueToGoStringContainer(v interface{}, typ string) string { pv := reflect.Indirect(rv).Interface() return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) } -func extensionToGoStringContainer(e map[int32]github_com_gogo_protobuf_proto.Extension) string { +func extensionToGoStringContainer(m github_com_gogo_protobuf_proto.Message) string { + e := github_com_gogo_protobuf_proto.GetUnsafeExtensionsMap(m) if e == nil { return "nil" } - s := "map[int32]proto.Extension{" + s := "proto.NewUnsafeXXX_InternalExtensions(map[int32]proto.Extension{" keys := make([]int, 0, len(e)) for k := range e { keys = append(keys, int(k)) @@ -845,7 +848,7 @@ func extensionToGoStringContainer(e map[int32]github_com_gogo_protobuf_proto.Ext for _, k := range keys { ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) } - s += strings.Join(ss, ",") + "}" + s += strings.Join(ss, ",") + "})" return s } @@ -853,6 +856,10 @@ func extensionToGoStringContainer(e map[int32]github_com_gogo_protobuf_proto.Ext var _ context.Context var _ grpc.ClientConn +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + // Client API for Containers service type ContainersClient interface { @@ -1063,172 +1070,256 @@ func RegisterContainersServer(s *grpc.Server, srv ContainersServer) { s.RegisterService(&_Containers_serviceDesc, srv) } -func _Containers_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) { +func _Containers_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(CreateRequest) if err := dec(in); err != nil { return nil, err } - out, err := srv.(ContainersServer).Create(ctx, in) - if err != nil { - return nil, err + if interceptor == nil { + return srv.(ContainersServer).Create(ctx, in) } - return out, nil + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.v1.Containers/Create", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ContainersServer).Create(ctx, req.(*CreateRequest)) + } + return interceptor(ctx, in, info, handler) } -func _Containers_Start_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) { +func _Containers_Start_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(StartRequest) if err := dec(in); err != nil { return nil, err } - out, err := srv.(ContainersServer).Start(ctx, in) - if err != nil { - return nil, err + if interceptor == nil { + return srv.(ContainersServer).Start(ctx, in) } - return out, nil + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.v1.Containers/Start", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ContainersServer).Start(ctx, req.(*StartRequest)) + } + return interceptor(ctx, in, info, handler) } -func _Containers_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) { +func _Containers_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(DeleteRequest) if err := dec(in); err != nil { return nil, err } - out, err := srv.(ContainersServer).Delete(ctx, in) - if err != nil { - return nil, err + if interceptor == nil { + return srv.(ContainersServer).Delete(ctx, in) } - return out, nil + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.v1.Containers/Delete", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ContainersServer).Delete(ctx, req.(*DeleteRequest)) + } + return interceptor(ctx, in, info, handler) } -func _Containers_State_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) { +func _Containers_State_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(StateRequest) if err := dec(in); err != nil { return nil, err } - out, err := srv.(ContainersServer).State(ctx, in) - if err != nil { - return nil, err + if interceptor == nil { + return srv.(ContainersServer).State(ctx, in) } - return out, nil + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.v1.Containers/State", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ContainersServer).State(ctx, req.(*StateRequest)) + } + return interceptor(ctx, in, info, handler) } -func _Containers_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) { +func _Containers_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(UpdateRequest) if err := dec(in); err != nil { return nil, err } - out, err := srv.(ContainersServer).Update(ctx, in) - if err != nil { - return nil, err + if interceptor == nil { + return srv.(ContainersServer).Update(ctx, in) } - return out, nil + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.v1.Containers/Update", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ContainersServer).Update(ctx, req.(*UpdateRequest)) + } + return interceptor(ctx, in, info, handler) } -func _Containers_Pause_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) { +func _Containers_Pause_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(PauseRequest) if err := dec(in); err != nil { return nil, err } - out, err := srv.(ContainersServer).Pause(ctx, in) - if err != nil { - return nil, err + if interceptor == nil { + return srv.(ContainersServer).Pause(ctx, in) } - return out, nil + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.v1.Containers/Pause", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ContainersServer).Pause(ctx, req.(*PauseRequest)) + } + return interceptor(ctx, in, info, handler) } -func _Containers_Resume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) { +func _Containers_Resume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ResumeRequest) if err := dec(in); err != nil { return nil, err } - out, err := srv.(ContainersServer).Resume(ctx, in) - if err != nil { - return nil, err + if interceptor == nil { + return srv.(ContainersServer).Resume(ctx, in) } - return out, nil + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.v1.Containers/Resume", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ContainersServer).Resume(ctx, req.(*ResumeRequest)) + } + return interceptor(ctx, in, info, handler) } -func _Containers_ContainerList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) { +func _Containers_ContainerList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ContainerListRequest) if err := dec(in); err != nil { return nil, err } - out, err := srv.(ContainersServer).ContainerList(ctx, in) - if err != nil { - return nil, err + if interceptor == nil { + return srv.(ContainersServer).ContainerList(ctx, in) } - return out, nil + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.v1.Containers/ContainerList", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ContainersServer).ContainerList(ctx, req.(*ContainerListRequest)) + } + return interceptor(ctx, in, info, handler) } -func _Containers_CreateProcess_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) { +func _Containers_CreateProcess_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(CreateProcessRequest) if err := dec(in); err != nil { return nil, err } - out, err := srv.(ContainersServer).CreateProcess(ctx, in) - if err != nil { - return nil, err + if interceptor == nil { + return srv.(ContainersServer).CreateProcess(ctx, in) } - return out, nil + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.v1.Containers/CreateProcess", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ContainersServer).CreateProcess(ctx, req.(*CreateProcessRequest)) + } + return interceptor(ctx, in, info, handler) } -func _Containers_StartProcess_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) { +func _Containers_StartProcess_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(StartProcessRequest) if err := dec(in); err != nil { return nil, err } - out, err := srv.(ContainersServer).StartProcess(ctx, in) - if err != nil { - return nil, err + if interceptor == nil { + return srv.(ContainersServer).StartProcess(ctx, in) } - return out, nil + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.v1.Containers/StartProcess", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ContainersServer).StartProcess(ctx, req.(*StartProcessRequest)) + } + return interceptor(ctx, in, info, handler) } -func _Containers_ProcessState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) { +func _Containers_ProcessState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ProcessStateRequest) if err := dec(in); err != nil { return nil, err } - out, err := srv.(ContainersServer).ProcessState(ctx, in) - if err != nil { - return nil, err + if interceptor == nil { + return srv.(ContainersServer).ProcessState(ctx, in) } - return out, nil + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.v1.Containers/ProcessState", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ContainersServer).ProcessState(ctx, req.(*ProcessStateRequest)) + } + return interceptor(ctx, in, info, handler) } -func _Containers_SignalProcess_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) { +func _Containers_SignalProcess_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(SignalProcessRequest) if err := dec(in); err != nil { return nil, err } - out, err := srv.(ContainersServer).SignalProcess(ctx, in) - if err != nil { - return nil, err + if interceptor == nil { + return srv.(ContainersServer).SignalProcess(ctx, in) } - return out, nil + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.v1.Containers/SignalProcess", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ContainersServer).SignalProcess(ctx, req.(*SignalProcessRequest)) + } + return interceptor(ctx, in, info, handler) } -func _Containers_DeleteProcess_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) { +func _Containers_DeleteProcess_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(DeleteProcessRequest) if err := dec(in); err != nil { return nil, err } - out, err := srv.(ContainersServer).DeleteProcess(ctx, in) - if err != nil { - return nil, err + if interceptor == nil { + return srv.(ContainersServer).DeleteProcess(ctx, in) } - return out, nil + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.v1.Containers/DeleteProcess", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ContainersServer).DeleteProcess(ctx, req.(*DeleteProcessRequest)) + } + return interceptor(ctx, in, info, handler) } -func _Containers_ProcessList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) { +func _Containers_ProcessList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ProcessListRequest) if err := dec(in); err != nil { return nil, err } - out, err := srv.(ContainersServer).ProcessList(ctx, in) - if err != nil { - return nil, err + if interceptor == nil { + return srv.(ContainersServer).ProcessList(ctx, in) } - return out, nil + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.v1.Containers/ProcessList", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ContainersServer).ProcessList(ctx, req.(*ProcessListRequest)) + } + return interceptor(ctx, in, info, handler) } func _Containers_Events_Handler(srv interface{}, stream grpc.ServerStream) error { @@ -1320,35 +1411,36 @@ var _Containers_serviceDesc = grpc.ServiceDesc{ ServerStreams: true, }, }, + Metadata: "container.proto", } -func (m *Container) Marshal() (data []byte, err error) { +func (m *Container) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *Container) MarshalTo(data []byte) (int, error) { +func (m *Container) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.ID) > 0 { - data[i] = 0xa + dAtA[i] = 0xa i++ - i = encodeVarintContainer(data, i, uint64(len(m.ID))) - i += copy(data[i:], m.ID) + i = encodeVarintContainer(dAtA, i, uint64(len(m.ID))) + i += copy(dAtA[i:], m.ID) } if len(m.Mounts) > 0 { for _, msg := range m.Mounts { - data[i] = 0x12 + dAtA[i] = 0x12 i++ - i = encodeVarintContainer(data, i, uint64(msg.Size())) - n, err := msg.MarshalTo(data[i:]) + i = encodeVarintContainer(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } @@ -1356,16 +1448,16 @@ func (m *Container) MarshalTo(data []byte) (int, error) { } } if len(m.Owner) > 0 { - data[i] = 0x1a + dAtA[i] = 0x1a i++ - i = encodeVarintContainer(data, i, uint64(len(m.Owner))) - i += copy(data[i:], m.Owner) + i = encodeVarintContainer(dAtA, i, uint64(len(m.Owner))) + i += copy(dAtA[i:], m.Owner) } if m.Process != nil { - data[i] = 0x22 + dAtA[i] = 0x22 i++ - i = encodeVarintContainer(data, i, uint64(m.Process.Size())) - n1, err := m.Process.MarshalTo(data[i:]) + i = encodeVarintContainer(dAtA, i, uint64(m.Process.Size())) + n1, err := m.Process.MarshalTo(dAtA[i:]) if err != nil { return 0, err } @@ -1374,568 +1466,351 @@ func (m *Container) MarshalTo(data []byte) (int, error) { return i, nil } -func (m *Process) Marshal() (data []byte, err error) { +func (m *Process) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *Process) MarshalTo(data []byte) (int, error) { +func (m *Process) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Pid != 0 { - data[i] = 0x8 + dAtA[i] = 0x8 i++ - i = encodeVarintContainer(data, i, uint64(m.Pid)) + i = encodeVarintContainer(dAtA, i, uint64(m.Pid)) } if len(m.Args) > 0 { for _, s := range m.Args { - data[i] = 0x12 + dAtA[i] = 0x12 i++ l = len(s) for l >= 1<<7 { - data[i] = uint8(uint64(l)&0x7f | 0x80) + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) l >>= 7 i++ } - data[i] = uint8(l) + dAtA[i] = uint8(l) i++ - i += copy(data[i:], s) + i += copy(dAtA[i:], s) } } if len(m.Env) > 0 { for _, s := range m.Env { - data[i] = 0x1a + dAtA[i] = 0x1a i++ l = len(s) for l >= 1<<7 { - data[i] = uint8(uint64(l)&0x7f | 0x80) + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) l >>= 7 i++ } - data[i] = uint8(l) + dAtA[i] = uint8(l) i++ - i += copy(data[i:], s) + i += copy(dAtA[i:], s) } } if m.User != nil { - data[i] = 0x22 + dAtA[i] = 0x22 i++ - i = encodeVarintContainer(data, i, uint64(m.User.Size())) - n2, err := m.User.MarshalTo(data[i:]) + i = encodeVarintContainer(dAtA, i, uint64(m.User.Size())) + n2, err := m.User.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n2 } if len(m.Cwd) > 0 { - data[i] = 0x2a + dAtA[i] = 0x2a i++ - i = encodeVarintContainer(data, i, uint64(len(m.Cwd))) - i += copy(data[i:], m.Cwd) + i = encodeVarintContainer(dAtA, i, uint64(len(m.Cwd))) + i += copy(dAtA[i:], m.Cwd) } if m.Terminal { - data[i] = 0x30 + dAtA[i] = 0x30 i++ if m.Terminal { - data[i] = 1 + dAtA[i] = 1 } else { - data[i] = 0 + dAtA[i] = 0 } i++ } return i, nil } -func (m *ProcessSpec) Marshal() (data []byte, err error) { +func (m *ProcessSpec) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *ProcessSpec) MarshalTo(data []byte) (int, error) { +func (m *ProcessSpec) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Args) > 0 { for _, s := range m.Args { - data[i] = 0xa + dAtA[i] = 0xa i++ l = len(s) for l >= 1<<7 { - data[i] = uint8(uint64(l)&0x7f | 0x80) + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) l >>= 7 i++ } - data[i] = uint8(l) + dAtA[i] = uint8(l) i++ - i += copy(data[i:], s) + i += copy(dAtA[i:], s) } } if len(m.Env) > 0 { for _, s := range m.Env { - data[i] = 0x12 + dAtA[i] = 0x12 i++ l = len(s) for l >= 1<<7 { - data[i] = uint8(uint64(l)&0x7f | 0x80) + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) l >>= 7 i++ } - data[i] = uint8(l) + dAtA[i] = uint8(l) i++ - i += copy(data[i:], s) + i += copy(dAtA[i:], s) } } if m.User != nil { - data[i] = 0x1a + dAtA[i] = 0x1a i++ - i = encodeVarintContainer(data, i, uint64(m.User.Size())) - n3, err := m.User.MarshalTo(data[i:]) + i = encodeVarintContainer(dAtA, i, uint64(m.User.Size())) + n3, err := m.User.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n3 } if len(m.Cwd) > 0 { - data[i] = 0x22 + dAtA[i] = 0x22 i++ - i = encodeVarintContainer(data, i, uint64(len(m.Cwd))) - i += copy(data[i:], m.Cwd) + i = encodeVarintContainer(dAtA, i, uint64(len(m.Cwd))) + i += copy(dAtA[i:], m.Cwd) } if m.Terminal { - data[i] = 0x28 + dAtA[i] = 0x28 i++ if m.Terminal { - data[i] = 1 + dAtA[i] = 1 } else { - data[i] = 0 + dAtA[i] = 0 } i++ } if len(m.Stdin) > 0 { - data[i] = 0x32 + dAtA[i] = 0x32 i++ - i = encodeVarintContainer(data, i, uint64(len(m.Stdin))) - i += copy(data[i:], m.Stdin) + i = encodeVarintContainer(dAtA, i, uint64(len(m.Stdin))) + i += copy(dAtA[i:], m.Stdin) } if len(m.Stdout) > 0 { - data[i] = 0x3a + dAtA[i] = 0x3a i++ - i = encodeVarintContainer(data, i, uint64(len(m.Stdout))) - i += copy(data[i:], m.Stdout) + i = encodeVarintContainer(dAtA, i, uint64(len(m.Stdout))) + i += copy(dAtA[i:], m.Stdout) } if len(m.Stderr) > 0 { - data[i] = 0x42 + dAtA[i] = 0x42 i++ - i = encodeVarintContainer(data, i, uint64(len(m.Stderr))) - i += copy(data[i:], m.Stderr) + i = encodeVarintContainer(dAtA, i, uint64(len(m.Stderr))) + i += copy(dAtA[i:], m.Stderr) } return i, nil } -func (m *Mount) Marshal() (data []byte, err error) { +func (m *Mount) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *Mount) MarshalTo(data []byte) (int, error) { +func (m *Mount) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Source) > 0 { - data[i] = 0xa + dAtA[i] = 0xa i++ - i = encodeVarintContainer(data, i, uint64(len(m.Source))) - i += copy(data[i:], m.Source) + i = encodeVarintContainer(dAtA, i, uint64(len(m.Source))) + i += copy(dAtA[i:], m.Source) } if len(m.Target) > 0 { - data[i] = 0x12 + dAtA[i] = 0x12 i++ - i = encodeVarintContainer(data, i, uint64(len(m.Target))) - i += copy(data[i:], m.Target) + i = encodeVarintContainer(dAtA, i, uint64(len(m.Target))) + i += copy(dAtA[i:], m.Target) } if len(m.Type) > 0 { - data[i] = 0x1a + dAtA[i] = 0x1a i++ - i = encodeVarintContainer(data, i, uint64(len(m.Type))) - i += copy(data[i:], m.Type) + i = encodeVarintContainer(dAtA, i, uint64(len(m.Type))) + i += copy(dAtA[i:], m.Type) } if len(m.Options) > 0 { for _, s := range m.Options { - data[i] = 0x22 + dAtA[i] = 0x22 i++ l = len(s) for l >= 1<<7 { - data[i] = uint8(uint64(l)&0x7f | 0x80) + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) l >>= 7 i++ } - data[i] = uint8(l) + dAtA[i] = uint8(l) i++ - i += copy(data[i:], s) + i += copy(dAtA[i:], s) } } return i, nil } -func (m *User) Marshal() (data []byte, err error) { +func (m *User) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *User) MarshalTo(data []byte) (int, error) { +func (m *User) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Uid != 0 { - data[i] = 0x8 + dAtA[i] = 0x8 i++ - i = encodeVarintContainer(data, i, uint64(m.Uid)) + i = encodeVarintContainer(dAtA, i, uint64(m.Uid)) } if m.Gid != 0 { - data[i] = 0x10 + dAtA[i] = 0x10 i++ - i = encodeVarintContainer(data, i, uint64(m.Gid)) + i = encodeVarintContainer(dAtA, i, uint64(m.Gid)) } if len(m.AdditionalGids) > 0 { + dAtA5 := make([]byte, len(m.AdditionalGids)*10) + var j4 int for _, num := range m.AdditionalGids { - data[i] = 0x18 - i++ - i = encodeVarintContainer(data, i, uint64(num)) + for num >= 1<<7 { + dAtA5[j4] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j4++ + } + dAtA5[j4] = uint8(num) + j4++ } + dAtA[i] = 0x1a + i++ + i = encodeVarintContainer(dAtA, i, uint64(j4)) + i += copy(dAtA[i:], dAtA5[:j4]) } return i, nil } -func (m *CreateRequest) Marshal() (data []byte, err error) { +func (m *CreateRequest) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *CreateRequest) MarshalTo(data []byte) (int, error) { +func (m *CreateRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.ID) > 0 { - data[i] = 0xa + dAtA[i] = 0xa i++ - i = encodeVarintContainer(data, i, uint64(len(m.ID))) - i += copy(data[i:], m.ID) + i = encodeVarintContainer(dAtA, i, uint64(len(m.ID))) + i += copy(dAtA[i:], m.ID) } if m.Process != nil { - data[i] = 0x12 + dAtA[i] = 0x12 i++ - i = encodeVarintContainer(data, i, uint64(m.Process.Size())) - n4, err := m.Process.MarshalTo(data[i:]) - if err != nil { - return 0, err - } - i += n4 - } - if len(m.Mounts) > 0 { - for _, msg := range m.Mounts { - data[i] = 0x1a - i++ - i = encodeVarintContainer(data, i, uint64(msg.Size())) - n, err := msg.MarshalTo(data[i:]) - if err != nil { - return 0, err - } - i += n - } - } - if len(m.Owner) > 0 { - data[i] = 0x22 - i++ - i = encodeVarintContainer(data, i, uint64(len(m.Owner))) - i += copy(data[i:], m.Owner) - } - if len(m.ConfigPath) > 0 { - data[i] = 0x2a - i++ - i = encodeVarintContainer(data, i, uint64(len(m.ConfigPath))) - i += copy(data[i:], m.ConfigPath) - } - return i, nil -} - -func (m *CreateResponse) Marshal() (data []byte, err error) { - size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) - if err != nil { - return nil, err - } - return data[:n], nil -} - -func (m *CreateResponse) MarshalTo(data []byte) (int, error) { - var i int - _ = i - var l int - _ = l - if m.Container != nil { - data[i] = 0xa - i++ - i = encodeVarintContainer(data, i, uint64(m.Container.Size())) - n5, err := m.Container.MarshalTo(data[i:]) - if err != nil { - return 0, err - } - i += n5 - } - return i, nil -} - -func (m *StartRequest) Marshal() (data []byte, err error) { - size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) - if err != nil { - return nil, err - } - return data[:n], nil -} - -func (m *StartRequest) MarshalTo(data []byte) (int, error) { - var i int - _ = i - var l int - _ = l - if len(m.ID) > 0 { - data[i] = 0xa - i++ - i = encodeVarintContainer(data, i, uint64(len(m.ID))) - i += copy(data[i:], m.ID) - } - return i, nil -} - -func (m *State) Marshal() (data []byte, err error) { - size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) - if err != nil { - return nil, err - } - return data[:n], nil -} - -func (m *State) MarshalTo(data []byte) (int, error) { - var i int - _ = i - var l int - _ = l - return i, nil -} - -func (m *StartResponse) Marshal() (data []byte, err error) { - size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) - if err != nil { - return nil, err - } - return data[:n], nil -} - -func (m *StartResponse) MarshalTo(data []byte) (int, error) { - var i int - _ = i - var l int - _ = l - if m.State != nil { - data[i] = 0xa - i++ - i = encodeVarintContainer(data, i, uint64(m.State.Size())) - n6, err := m.State.MarshalTo(data[i:]) + i = encodeVarintContainer(dAtA, i, uint64(m.Process.Size())) + n6, err := m.Process.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n6 } - return i, nil -} - -func (m *DeleteRequest) Marshal() (data []byte, err error) { - size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) - if err != nil { - return nil, err - } - return data[:n], nil -} - -func (m *DeleteRequest) MarshalTo(data []byte) (int, error) { - var i int - _ = i - var l int - _ = l - if len(m.ID) > 0 { - data[i] = 0xa - i++ - i = encodeVarintContainer(data, i, uint64(len(m.ID))) - i += copy(data[i:], m.ID) - } - return i, nil -} - -func (m *DeleteResponse) Marshal() (data []byte, err error) { - size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) - if err != nil { - return nil, err - } - return data[:n], nil -} - -func (m *DeleteResponse) MarshalTo(data []byte) (int, error) { - var i int - _ = i - var l int - _ = l - return i, nil -} - -func (m *ContainerListRequest) Marshal() (data []byte, err error) { - size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) - if err != nil { - return nil, err - } - return data[:n], nil -} - -func (m *ContainerListRequest) MarshalTo(data []byte) (int, error) { - var i int - _ = i - var l int - _ = l - if len(m.Owner) > 0 { - for _, s := range m.Owner { - data[i] = 0xa + if len(m.Mounts) > 0 { + for _, msg := range m.Mounts { + dAtA[i] = 0x1a i++ - l = len(s) - for l >= 1<<7 { - data[i] = uint8(uint64(l)&0x7f | 0x80) - l >>= 7 - i++ - } - data[i] = uint8(l) - i++ - i += copy(data[i:], s) - } - } - return i, nil -} - -func (m *ContainerListResponse) Marshal() (data []byte, err error) { - size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) - if err != nil { - return nil, err - } - return data[:n], nil -} - -func (m *ContainerListResponse) MarshalTo(data []byte) (int, error) { - var i int - _ = i - var l int - _ = l - if len(m.Containers) > 0 { - for _, msg := range m.Containers { - data[i] = 0xa - i++ - i = encodeVarintContainer(data, i, uint64(msg.Size())) - n, err := msg.MarshalTo(data[i:]) + i = encodeVarintContainer(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } - return i, nil -} - -func (m *StateRequest) Marshal() (data []byte, err error) { - size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) - if err != nil { - return nil, err - } - return data[:n], nil -} - -func (m *StateRequest) MarshalTo(data []byte) (int, error) { - var i int - _ = i - var l int - _ = l - if len(m.ID) > 0 { - data[i] = 0xa + if len(m.Owner) > 0 { + dAtA[i] = 0x22 i++ - i = encodeVarintContainer(data, i, uint64(len(m.ID))) - i += copy(data[i:], m.ID) + i = encodeVarintContainer(dAtA, i, uint64(len(m.Owner))) + i += copy(dAtA[i:], m.Owner) + } + if len(m.ConfigPath) > 0 { + dAtA[i] = 0x2a + i++ + i = encodeVarintContainer(dAtA, i, uint64(len(m.ConfigPath))) + i += copy(dAtA[i:], m.ConfigPath) } return i, nil } -func (m *StateResponse) Marshal() (data []byte, err error) { +func (m *CreateResponse) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *StateResponse) MarshalTo(data []byte) (int, error) { +func (m *CreateResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Container != nil { - data[i] = 0xa + dAtA[i] = 0xa i++ - i = encodeVarintContainer(data, i, uint64(m.Container.Size())) - n7, err := m.Container.MarshalTo(data[i:]) + i = encodeVarintContainer(dAtA, i, uint64(m.Container.Size())) + n7, err := m.Container.MarshalTo(dAtA[i:]) if err != nil { return 0, err } @@ -1944,41 +1819,41 @@ func (m *StateResponse) MarshalTo(data []byte) (int, error) { return i, nil } -func (m *UpdateRequest) Marshal() (data []byte, err error) { +func (m *StartRequest) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *UpdateRequest) MarshalTo(data []byte) (int, error) { +func (m *StartRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.ID) > 0 { - data[i] = 0xa + dAtA[i] = 0xa i++ - i = encodeVarintContainer(data, i, uint64(len(m.ID))) - i += copy(data[i:], m.ID) + i = encodeVarintContainer(dAtA, i, uint64(len(m.ID))) + i += copy(dAtA[i:], m.ID) } return i, nil } -func (m *UpdateResponse) Marshal() (data []byte, err error) { +func (m *State) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *UpdateResponse) MarshalTo(data []byte) (int, error) { +func (m *State) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int @@ -1986,116 +1861,26 @@ func (m *UpdateResponse) MarshalTo(data []byte) (int, error) { return i, nil } -func (m *PauseRequest) Marshal() (data []byte, err error) { +func (m *StartResponse) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *PauseRequest) MarshalTo(data []byte) (int, error) { +func (m *StartResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l - if len(m.ID) > 0 { - data[i] = 0xa + if m.State != nil { + dAtA[i] = 0xa i++ - i = encodeVarintContainer(data, i, uint64(len(m.ID))) - i += copy(data[i:], m.ID) - } - return i, nil -} - -func (m *PauseResponse) Marshal() (data []byte, err error) { - size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) - if err != nil { - return nil, err - } - return data[:n], nil -} - -func (m *PauseResponse) MarshalTo(data []byte) (int, error) { - var i int - _ = i - var l int - _ = l - return i, nil -} - -func (m *ResumeRequest) Marshal() (data []byte, err error) { - size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) - if err != nil { - return nil, err - } - return data[:n], nil -} - -func (m *ResumeRequest) MarshalTo(data []byte) (int, error) { - var i int - _ = i - var l int - _ = l - if len(m.ID) > 0 { - data[i] = 0xa - i++ - i = encodeVarintContainer(data, i, uint64(len(m.ID))) - i += copy(data[i:], m.ID) - } - return i, nil -} - -func (m *ResumeResponse) Marshal() (data []byte, err error) { - size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) - if err != nil { - return nil, err - } - return data[:n], nil -} - -func (m *ResumeResponse) MarshalTo(data []byte) (int, error) { - var i int - _ = i - var l int - _ = l - return i, nil -} - -func (m *CreateProcessRequest) Marshal() (data []byte, err error) { - size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) - if err != nil { - return nil, err - } - return data[:n], nil -} - -func (m *CreateProcessRequest) MarshalTo(data []byte) (int, error) { - var i int - _ = i - var l int - _ = l - if len(m.ID) > 0 { - data[i] = 0xa - i++ - i = encodeVarintContainer(data, i, uint64(len(m.ID))) - i += copy(data[i:], m.ID) - } - if m.Spec != nil { - data[i] = 0x12 - i++ - i = encodeVarintContainer(data, i, uint64(m.Spec.Size())) - n8, err := m.Spec.MarshalTo(data[i:]) + i = encodeVarintContainer(dAtA, i, uint64(m.State.Size())) + n8, err := m.State.MarshalTo(dAtA[i:]) if err != nil { return 0, err } @@ -2104,17 +1889,41 @@ func (m *CreateProcessRequest) MarshalTo(data []byte) (int, error) { return i, nil } -func (m *CreateProcessResponse) Marshal() (data []byte, err error) { +func (m *DeleteRequest) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *CreateProcessResponse) MarshalTo(data []byte) (int, error) { +func (m *DeleteRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.ID) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintContainer(dAtA, i, uint64(len(m.ID))) + i += copy(dAtA[i:], m.ID) + } + return i, nil +} + +func (m *DeleteResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DeleteResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int @@ -2122,109 +1931,113 @@ func (m *CreateProcessResponse) MarshalTo(data []byte) (int, error) { return i, nil } -func (m *StartProcessRequest) Marshal() (data []byte, err error) { +func (m *ContainerListRequest) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *StartProcessRequest) MarshalTo(data []byte) (int, error) { +func (m *ContainerListRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l - if len(m.Cid) > 0 { - data[i] = 0xa - i++ - i = encodeVarintContainer(data, i, uint64(len(m.Cid))) - i += copy(data[i:], m.Cid) - } - if len(m.Pid) > 0 { - data[i] = 0x12 - i++ - i = encodeVarintContainer(data, i, uint64(len(m.Pid))) - i += copy(data[i:], m.Pid) + if len(m.Owner) > 0 { + for _, s := range m.Owner { + dAtA[i] = 0xa + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } } return i, nil } -func (m *StartProcessResponse) Marshal() (data []byte, err error) { +func (m *ContainerListResponse) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *StartProcessResponse) MarshalTo(data []byte) (int, error) { +func (m *ContainerListResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l - if m.Pid != 0 { - data[i] = 0x8 - i++ - i = encodeVarintContainer(data, i, uint64(m.Pid)) + if len(m.Containers) > 0 { + for _, msg := range m.Containers { + dAtA[i] = 0xa + i++ + i = encodeVarintContainer(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } } return i, nil } -func (m *ProcessStateRequest) Marshal() (data []byte, err error) { +func (m *StateRequest) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *ProcessStateRequest) MarshalTo(data []byte) (int, error) { +func (m *StateRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l - if len(m.Cid) > 0 { - data[i] = 0xa + if len(m.ID) > 0 { + dAtA[i] = 0xa i++ - i = encodeVarintContainer(data, i, uint64(len(m.Cid))) - i += copy(data[i:], m.Cid) - } - if len(m.Pid) > 0 { - data[i] = 0x12 - i++ - i = encodeVarintContainer(data, i, uint64(len(m.Pid))) - i += copy(data[i:], m.Pid) + i = encodeVarintContainer(dAtA, i, uint64(len(m.ID))) + i += copy(dAtA[i:], m.ID) } return i, nil } -func (m *ProcessStateResponse) Marshal() (data []byte, err error) { +func (m *StateResponse) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *ProcessStateResponse) MarshalTo(data []byte) (int, error) { +func (m *StateResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l - if m.State != nil { - data[i] = 0xa + if m.Container != nil { + dAtA[i] = 0xa i++ - i = encodeVarintContainer(data, i, uint64(m.State.Size())) - n9, err := m.State.MarshalTo(data[i:]) + i = encodeVarintContainer(dAtA, i, uint64(m.Container.Size())) + n9, err := m.Container.MarshalTo(dAtA[i:]) if err != nil { return 0, err } @@ -2233,142 +2046,41 @@ func (m *ProcessStateResponse) MarshalTo(data []byte) (int, error) { return i, nil } -func (m *SignalProcessRequest) Marshal() (data []byte, err error) { +func (m *UpdateRequest) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *SignalProcessRequest) MarshalTo(data []byte) (int, error) { - var i int - _ = i - var l int - _ = l - if len(m.Cid) > 0 { - data[i] = 0xa - i++ - i = encodeVarintContainer(data, i, uint64(len(m.Cid))) - i += copy(data[i:], m.Cid) - } - if len(m.Pid) > 0 { - data[i] = 0x12 - i++ - i = encodeVarintContainer(data, i, uint64(len(m.Pid))) - i += copy(data[i:], m.Pid) - } - if m.Signal != 0 { - data[i] = 0x18 - i++ - i = encodeVarintContainer(data, i, uint64(m.Signal)) - } - return i, nil -} - -func (m *SignalProcessResponse) Marshal() (data []byte, err error) { - size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) - if err != nil { - return nil, err - } - return data[:n], nil -} - -func (m *SignalProcessResponse) MarshalTo(data []byte) (int, error) { - var i int - _ = i - var l int - _ = l - return i, nil -} - -func (m *DeleteProcessRequest) Marshal() (data []byte, err error) { - size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) - if err != nil { - return nil, err - } - return data[:n], nil -} - -func (m *DeleteProcessRequest) MarshalTo(data []byte) (int, error) { - var i int - _ = i - var l int - _ = l - if len(m.Cid) > 0 { - data[i] = 0xa - i++ - i = encodeVarintContainer(data, i, uint64(len(m.Cid))) - i += copy(data[i:], m.Cid) - } - if len(m.Pid) > 0 { - data[i] = 0x12 - i++ - i = encodeVarintContainer(data, i, uint64(len(m.Pid))) - i += copy(data[i:], m.Pid) - } - return i, nil -} - -func (m *DeleteProcessResponse) Marshal() (data []byte, err error) { - size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) - if err != nil { - return nil, err - } - return data[:n], nil -} - -func (m *DeleteProcessResponse) MarshalTo(data []byte) (int, error) { - var i int - _ = i - var l int - _ = l - return i, nil -} - -func (m *ProcessListRequest) Marshal() (data []byte, err error) { - size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) - if err != nil { - return nil, err - } - return data[:n], nil -} - -func (m *ProcessListRequest) MarshalTo(data []byte) (int, error) { +func (m *UpdateRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.ID) > 0 { - data[i] = 0xa + dAtA[i] = 0xa i++ - i = encodeVarintContainer(data, i, uint64(len(m.ID))) - i += copy(data[i:], m.ID) + i = encodeVarintContainer(dAtA, i, uint64(len(m.ID))) + i += copy(dAtA[i:], m.ID) } return i, nil } -func (m *ProcessListResponse) Marshal() (data []byte, err error) { +func (m *UpdateResponse) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *ProcessListResponse) MarshalTo(data []byte) (int, error) { +func (m *UpdateResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int @@ -2376,17 +2088,41 @@ func (m *ProcessListResponse) MarshalTo(data []byte) (int, error) { return i, nil } -func (m *EventsRequest) Marshal() (data []byte, err error) { +func (m *PauseRequest) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *EventsRequest) MarshalTo(data []byte) (int, error) { +func (m *PauseRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.ID) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintContainer(dAtA, i, uint64(len(m.ID))) + i += copy(dAtA[i:], m.ID) + } + return i, nil +} + +func (m *PauseResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PauseResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int @@ -2394,17 +2130,41 @@ func (m *EventsRequest) MarshalTo(data []byte) (int, error) { return i, nil } -func (m *EventsResponse) Marshal() (data []byte, err error) { +func (m *ResumeRequest) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *EventsResponse) MarshalTo(data []byte) (int, error) { +func (m *ResumeRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.ID) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintContainer(dAtA, i, uint64(len(m.ID))) + i += copy(dAtA[i:], m.ID) + } + return i, nil +} + +func (m *ResumeResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ResumeResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int @@ -2412,31 +2172,373 @@ func (m *EventsResponse) MarshalTo(data []byte) (int, error) { return i, nil } -func encodeFixed64Container(data []byte, offset int, v uint64) int { - data[offset] = uint8(v) - data[offset+1] = uint8(v >> 8) - data[offset+2] = uint8(v >> 16) - data[offset+3] = uint8(v >> 24) - data[offset+4] = uint8(v >> 32) - data[offset+5] = uint8(v >> 40) - data[offset+6] = uint8(v >> 48) - data[offset+7] = uint8(v >> 56) +func (m *CreateProcessRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CreateProcessRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.ID) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintContainer(dAtA, i, uint64(len(m.ID))) + i += copy(dAtA[i:], m.ID) + } + if m.Spec != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintContainer(dAtA, i, uint64(m.Spec.Size())) + n10, err := m.Spec.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n10 + } + return i, nil +} + +func (m *CreateProcessResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CreateProcessResponse) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + return i, nil +} + +func (m *StartProcessRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StartProcessRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Cid) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintContainer(dAtA, i, uint64(len(m.Cid))) + i += copy(dAtA[i:], m.Cid) + } + if len(m.Pid) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintContainer(dAtA, i, uint64(len(m.Pid))) + i += copy(dAtA[i:], m.Pid) + } + return i, nil +} + +func (m *StartProcessResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StartProcessResponse) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Pid != 0 { + dAtA[i] = 0x8 + i++ + i = encodeVarintContainer(dAtA, i, uint64(m.Pid)) + } + return i, nil +} + +func (m *ProcessStateRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ProcessStateRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Cid) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintContainer(dAtA, i, uint64(len(m.Cid))) + i += copy(dAtA[i:], m.Cid) + } + if len(m.Pid) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintContainer(dAtA, i, uint64(len(m.Pid))) + i += copy(dAtA[i:], m.Pid) + } + return i, nil +} + +func (m *ProcessStateResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ProcessStateResponse) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.State != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintContainer(dAtA, i, uint64(m.State.Size())) + n11, err := m.State.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n11 + } + return i, nil +} + +func (m *SignalProcessRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SignalProcessRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Cid) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintContainer(dAtA, i, uint64(len(m.Cid))) + i += copy(dAtA[i:], m.Cid) + } + if len(m.Pid) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintContainer(dAtA, i, uint64(len(m.Pid))) + i += copy(dAtA[i:], m.Pid) + } + if m.Signal != 0 { + dAtA[i] = 0x18 + i++ + i = encodeVarintContainer(dAtA, i, uint64(m.Signal)) + } + return i, nil +} + +func (m *SignalProcessResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SignalProcessResponse) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + return i, nil +} + +func (m *DeleteProcessRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DeleteProcessRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Cid) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintContainer(dAtA, i, uint64(len(m.Cid))) + i += copy(dAtA[i:], m.Cid) + } + if len(m.Pid) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintContainer(dAtA, i, uint64(len(m.Pid))) + i += copy(dAtA[i:], m.Pid) + } + return i, nil +} + +func (m *DeleteProcessResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DeleteProcessResponse) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + return i, nil +} + +func (m *ProcessListRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ProcessListRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.ID) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintContainer(dAtA, i, uint64(len(m.ID))) + i += copy(dAtA[i:], m.ID) + } + return i, nil +} + +func (m *ProcessListResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ProcessListResponse) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + return i, nil +} + +func (m *EventsRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventsRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + return i, nil +} + +func (m *EventsResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventsResponse) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + return i, nil +} + +func encodeFixed64Container(dAtA []byte, offset int, v uint64) int { + dAtA[offset] = uint8(v) + dAtA[offset+1] = uint8(v >> 8) + dAtA[offset+2] = uint8(v >> 16) + dAtA[offset+3] = uint8(v >> 24) + dAtA[offset+4] = uint8(v >> 32) + dAtA[offset+5] = uint8(v >> 40) + dAtA[offset+6] = uint8(v >> 48) + dAtA[offset+7] = uint8(v >> 56) return offset + 8 } -func encodeFixed32Container(data []byte, offset int, v uint32) int { - data[offset] = uint8(v) - data[offset+1] = uint8(v >> 8) - data[offset+2] = uint8(v >> 16) - data[offset+3] = uint8(v >> 24) +func encodeFixed32Container(dAtA []byte, offset int, v uint32) int { + dAtA[offset] = uint8(v) + dAtA[offset+1] = uint8(v >> 8) + dAtA[offset+2] = uint8(v >> 16) + dAtA[offset+3] = uint8(v >> 24) return offset + 4 } -func encodeVarintContainer(data []byte, offset int, v uint64) int { +func encodeVarintContainer(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { - data[offset] = uint8(v&0x7f | 0x80) + dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } - data[offset] = uint8(v) + dAtA[offset] = uint8(v) return offset + 1 } func (m *Container) Size() (n int) { @@ -2570,9 +2672,11 @@ func (m *User) Size() (n int) { n += 1 + sovContainer(uint64(m.Gid)) } if len(m.AdditionalGids) > 0 { + l = 0 for _, e := range m.AdditionalGids { - n += 1 + sovContainer(uint64(e)) + l += sovContainer(uint64(e)) } + n += 1 + sovContainer(uint64(l)) + l } return n } @@ -3287,8 +3391,8 @@ func valueToStringContainer(v interface{}) string { pv := reflect.Indirect(rv).Interface() return fmt.Sprintf("*%v", pv) } -func (m *Container) Unmarshal(data []byte) error { - l := len(data) +func (m *Container) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -3300,7 +3404,7 @@ func (m *Container) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -3328,7 +3432,7 @@ func (m *Container) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -3343,7 +3447,7 @@ func (m *Container) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ID = string(data[iNdEx:postIndex]) + m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { @@ -3357,7 +3461,7 @@ func (m *Container) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { @@ -3372,7 +3476,7 @@ func (m *Container) Unmarshal(data []byte) error { return io.ErrUnexpectedEOF } m.Mounts = append(m.Mounts, &Mount{}) - if err := m.Mounts[len(m.Mounts)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + if err := m.Mounts[len(m.Mounts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -3388,7 +3492,7 @@ func (m *Container) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -3403,7 +3507,7 @@ func (m *Container) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Owner = string(data[iNdEx:postIndex]) + m.Owner = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { @@ -3417,7 +3521,7 @@ func (m *Container) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { @@ -3434,13 +3538,13 @@ func (m *Container) Unmarshal(data []byte) error { if m.Process == nil { m.Process = &Process{} } - if err := m.Process.Unmarshal(data[iNdEx:postIndex]); err != nil { + if err := m.Process.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -3459,8 +3563,8 @@ func (m *Container) Unmarshal(data []byte) error { } return nil } -func (m *Process) Unmarshal(data []byte) error { - l := len(data) +func (m *Process) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -3472,7 +3576,7 @@ func (m *Process) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -3500,7 +3604,7 @@ func (m *Process) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ m.Pid |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -3519,7 +3623,7 @@ func (m *Process) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -3534,7 +3638,7 @@ func (m *Process) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Args = append(m.Args, string(data[iNdEx:postIndex])) + m.Args = append(m.Args, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex case 3: if wireType != 2 { @@ -3548,7 +3652,7 @@ func (m *Process) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -3563,7 +3667,7 @@ func (m *Process) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Env = append(m.Env, string(data[iNdEx:postIndex])) + m.Env = append(m.Env, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex case 4: if wireType != 2 { @@ -3577,7 +3681,7 @@ func (m *Process) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { @@ -3594,7 +3698,7 @@ func (m *Process) Unmarshal(data []byte) error { if m.User == nil { m.User = &User{} } - if err := m.User.Unmarshal(data[iNdEx:postIndex]); err != nil { + if err := m.User.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -3610,7 +3714,7 @@ func (m *Process) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -3625,7 +3729,7 @@ func (m *Process) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Cwd = string(data[iNdEx:postIndex]) + m.Cwd = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 6: if wireType != 0 { @@ -3639,7 +3743,7 @@ func (m *Process) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { @@ -3649,7 +3753,7 @@ func (m *Process) Unmarshal(data []byte) error { m.Terminal = bool(v != 0) default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -3668,8 +3772,8 @@ func (m *Process) Unmarshal(data []byte) error { } return nil } -func (m *ProcessSpec) Unmarshal(data []byte) error { - l := len(data) +func (m *ProcessSpec) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -3681,7 +3785,7 @@ func (m *ProcessSpec) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -3709,7 +3813,7 @@ func (m *ProcessSpec) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -3724,7 +3828,7 @@ func (m *ProcessSpec) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Args = append(m.Args, string(data[iNdEx:postIndex])) + m.Args = append(m.Args, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex case 2: if wireType != 2 { @@ -3738,7 +3842,7 @@ func (m *ProcessSpec) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -3753,7 +3857,7 @@ func (m *ProcessSpec) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Env = append(m.Env, string(data[iNdEx:postIndex])) + m.Env = append(m.Env, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex case 3: if wireType != 2 { @@ -3767,7 +3871,7 @@ func (m *ProcessSpec) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { @@ -3784,7 +3888,7 @@ func (m *ProcessSpec) Unmarshal(data []byte) error { if m.User == nil { m.User = &User{} } - if err := m.User.Unmarshal(data[iNdEx:postIndex]); err != nil { + if err := m.User.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -3800,7 +3904,7 @@ func (m *ProcessSpec) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -3815,7 +3919,7 @@ func (m *ProcessSpec) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Cwd = string(data[iNdEx:postIndex]) + m.Cwd = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 5: if wireType != 0 { @@ -3829,7 +3933,7 @@ func (m *ProcessSpec) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { @@ -3849,7 +3953,7 @@ func (m *ProcessSpec) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -3864,7 +3968,7 @@ func (m *ProcessSpec) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Stdin = string(data[iNdEx:postIndex]) + m.Stdin = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 7: if wireType != 2 { @@ -3878,7 +3982,7 @@ func (m *ProcessSpec) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -3893,7 +3997,7 @@ func (m *ProcessSpec) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Stdout = string(data[iNdEx:postIndex]) + m.Stdout = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 8: if wireType != 2 { @@ -3907,7 +4011,7 @@ func (m *ProcessSpec) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -3922,11 +4026,11 @@ func (m *ProcessSpec) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Stderr = string(data[iNdEx:postIndex]) + m.Stderr = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -3945,8 +4049,8 @@ func (m *ProcessSpec) Unmarshal(data []byte) error { } return nil } -func (m *Mount) Unmarshal(data []byte) error { - l := len(data) +func (m *Mount) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -3958,7 +4062,7 @@ func (m *Mount) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -3986,7 +4090,7 @@ func (m *Mount) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -4001,7 +4105,7 @@ func (m *Mount) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Source = string(data[iNdEx:postIndex]) + m.Source = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { @@ -4015,7 +4119,7 @@ func (m *Mount) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -4030,7 +4134,7 @@ func (m *Mount) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Target = string(data[iNdEx:postIndex]) + m.Target = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { @@ -4044,7 +4148,7 @@ func (m *Mount) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -4059,7 +4163,7 @@ func (m *Mount) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Type = string(data[iNdEx:postIndex]) + m.Type = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { @@ -4073,7 +4177,7 @@ func (m *Mount) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -4088,11 +4192,11 @@ func (m *Mount) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Options = append(m.Options, string(data[iNdEx:postIndex])) + m.Options = append(m.Options, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -4111,8 +4215,8 @@ func (m *Mount) Unmarshal(data []byte) error { } return nil } -func (m *User) Unmarshal(data []byte) error { - l := len(data) +func (m *User) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -4124,7 +4228,7 @@ func (m *User) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -4152,7 +4256,7 @@ func (m *User) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ m.Uid |= (uint32(b) & 0x7F) << shift if b < 0x80 { @@ -4171,7 +4275,7 @@ func (m *User) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ m.Gid |= (uint32(b) & 0x7F) << shift if b < 0x80 { @@ -4179,28 +4283,70 @@ func (m *User) Unmarshal(data []byte) error { } } case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field AdditionalGids", wireType) - } - var v uint32 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowContainer + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowContainer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } } - if iNdEx >= l { + if packedLen < 0 { + return ErrInvalidLengthContainer + } + postIndex := iNdEx + packedLen + if postIndex > l { return io.ErrUnexpectedEOF } - b := data[iNdEx] - iNdEx++ - v |= (uint32(b) & 0x7F) << shift - if b < 0x80 { - break + for iNdEx < postIndex { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowContainer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.AdditionalGids = append(m.AdditionalGids, v) } + } else if wireType == 0 { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowContainer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.AdditionalGids = append(m.AdditionalGids, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field AdditionalGids", wireType) } - m.AdditionalGids = append(m.AdditionalGids, v) default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -4219,8 +4365,8 @@ func (m *User) Unmarshal(data []byte) error { } return nil } -func (m *CreateRequest) Unmarshal(data []byte) error { - l := len(data) +func (m *CreateRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -4232,7 +4378,7 @@ func (m *CreateRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -4260,7 +4406,7 @@ func (m *CreateRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -4275,7 +4421,7 @@ func (m *CreateRequest) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ID = string(data[iNdEx:postIndex]) + m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { @@ -4289,7 +4435,7 @@ func (m *CreateRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { @@ -4306,7 +4452,7 @@ func (m *CreateRequest) Unmarshal(data []byte) error { if m.Process == nil { m.Process = &ProcessSpec{} } - if err := m.Process.Unmarshal(data[iNdEx:postIndex]); err != nil { + if err := m.Process.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -4322,7 +4468,7 @@ func (m *CreateRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { @@ -4337,7 +4483,7 @@ func (m *CreateRequest) Unmarshal(data []byte) error { return io.ErrUnexpectedEOF } m.Mounts = append(m.Mounts, &Mount{}) - if err := m.Mounts[len(m.Mounts)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + if err := m.Mounts[len(m.Mounts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -4353,7 +4499,7 @@ func (m *CreateRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -4368,7 +4514,7 @@ func (m *CreateRequest) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Owner = string(data[iNdEx:postIndex]) + m.Owner = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 5: if wireType != 2 { @@ -4382,7 +4528,7 @@ func (m *CreateRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -4397,11 +4543,11 @@ func (m *CreateRequest) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ConfigPath = string(data[iNdEx:postIndex]) + m.ConfigPath = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -4420,8 +4566,8 @@ func (m *CreateRequest) Unmarshal(data []byte) error { } return nil } -func (m *CreateResponse) Unmarshal(data []byte) error { - l := len(data) +func (m *CreateResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -4433,7 +4579,7 @@ func (m *CreateResponse) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -4461,7 +4607,7 @@ func (m *CreateResponse) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { @@ -4478,13 +4624,13 @@ func (m *CreateResponse) Unmarshal(data []byte) error { if m.Container == nil { m.Container = &Container{} } - if err := m.Container.Unmarshal(data[iNdEx:postIndex]); err != nil { + if err := m.Container.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -4503,8 +4649,8 @@ func (m *CreateResponse) Unmarshal(data []byte) error { } return nil } -func (m *StartRequest) Unmarshal(data []byte) error { - l := len(data) +func (m *StartRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -4516,7 +4662,7 @@ func (m *StartRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -4544,7 +4690,7 @@ func (m *StartRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -4559,11 +4705,11 @@ func (m *StartRequest) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ID = string(data[iNdEx:postIndex]) + m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -4582,8 +4728,8 @@ func (m *StartRequest) Unmarshal(data []byte) error { } return nil } -func (m *State) Unmarshal(data []byte) error { - l := len(data) +func (m *State) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -4595,7 +4741,7 @@ func (m *State) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -4613,7 +4759,7 @@ func (m *State) Unmarshal(data []byte) error { switch fieldNum { default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -4632,8 +4778,8 @@ func (m *State) Unmarshal(data []byte) error { } return nil } -func (m *StartResponse) Unmarshal(data []byte) error { - l := len(data) +func (m *StartResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -4645,7 +4791,7 @@ func (m *StartResponse) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -4673,7 +4819,7 @@ func (m *StartResponse) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { @@ -4690,13 +4836,13 @@ func (m *StartResponse) Unmarshal(data []byte) error { if m.State == nil { m.State = &State{} } - if err := m.State.Unmarshal(data[iNdEx:postIndex]); err != nil { + if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -4715,8 +4861,8 @@ func (m *StartResponse) Unmarshal(data []byte) error { } return nil } -func (m *DeleteRequest) Unmarshal(data []byte) error { - l := len(data) +func (m *DeleteRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -4728,7 +4874,7 @@ func (m *DeleteRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -4756,7 +4902,7 @@ func (m *DeleteRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -4771,11 +4917,11 @@ func (m *DeleteRequest) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ID = string(data[iNdEx:postIndex]) + m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -4794,8 +4940,8 @@ func (m *DeleteRequest) Unmarshal(data []byte) error { } return nil } -func (m *DeleteResponse) Unmarshal(data []byte) error { - l := len(data) +func (m *DeleteResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -4807,7 +4953,7 @@ func (m *DeleteResponse) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -4825,7 +4971,7 @@ func (m *DeleteResponse) Unmarshal(data []byte) error { switch fieldNum { default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -4844,8 +4990,8 @@ func (m *DeleteResponse) Unmarshal(data []byte) error { } return nil } -func (m *ContainerListRequest) Unmarshal(data []byte) error { - l := len(data) +func (m *ContainerListRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -4857,7 +5003,7 @@ func (m *ContainerListRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -4885,7 +5031,7 @@ func (m *ContainerListRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -4900,11 +5046,11 @@ func (m *ContainerListRequest) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Owner = append(m.Owner, string(data[iNdEx:postIndex])) + m.Owner = append(m.Owner, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -4923,8 +5069,8 @@ func (m *ContainerListRequest) Unmarshal(data []byte) error { } return nil } -func (m *ContainerListResponse) Unmarshal(data []byte) error { - l := len(data) +func (m *ContainerListResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -4936,7 +5082,7 @@ func (m *ContainerListResponse) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -4964,7 +5110,7 @@ func (m *ContainerListResponse) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { @@ -4979,13 +5125,13 @@ func (m *ContainerListResponse) Unmarshal(data []byte) error { return io.ErrUnexpectedEOF } m.Containers = append(m.Containers, &Container{}) - if err := m.Containers[len(m.Containers)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + if err := m.Containers[len(m.Containers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -5004,8 +5150,8 @@ func (m *ContainerListResponse) Unmarshal(data []byte) error { } return nil } -func (m *StateRequest) Unmarshal(data []byte) error { - l := len(data) +func (m *StateRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -5017,7 +5163,7 @@ func (m *StateRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -5045,7 +5191,7 @@ func (m *StateRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -5060,11 +5206,11 @@ func (m *StateRequest) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ID = string(data[iNdEx:postIndex]) + m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -5083,8 +5229,8 @@ func (m *StateRequest) Unmarshal(data []byte) error { } return nil } -func (m *StateResponse) Unmarshal(data []byte) error { - l := len(data) +func (m *StateResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -5096,7 +5242,7 @@ func (m *StateResponse) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -5124,7 +5270,7 @@ func (m *StateResponse) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { @@ -5141,13 +5287,13 @@ func (m *StateResponse) Unmarshal(data []byte) error { if m.Container == nil { m.Container = &Container{} } - if err := m.Container.Unmarshal(data[iNdEx:postIndex]); err != nil { + if err := m.Container.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -5166,8 +5312,8 @@ func (m *StateResponse) Unmarshal(data []byte) error { } return nil } -func (m *UpdateRequest) Unmarshal(data []byte) error { - l := len(data) +func (m *UpdateRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -5179,7 +5325,7 @@ func (m *UpdateRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -5207,7 +5353,7 @@ func (m *UpdateRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -5222,11 +5368,11 @@ func (m *UpdateRequest) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ID = string(data[iNdEx:postIndex]) + m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -5245,8 +5391,8 @@ func (m *UpdateRequest) Unmarshal(data []byte) error { } return nil } -func (m *UpdateResponse) Unmarshal(data []byte) error { - l := len(data) +func (m *UpdateResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -5258,7 +5404,7 @@ func (m *UpdateResponse) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -5276,7 +5422,7 @@ func (m *UpdateResponse) Unmarshal(data []byte) error { switch fieldNum { default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -5295,8 +5441,8 @@ func (m *UpdateResponse) Unmarshal(data []byte) error { } return nil } -func (m *PauseRequest) Unmarshal(data []byte) error { - l := len(data) +func (m *PauseRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -5308,7 +5454,7 @@ func (m *PauseRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -5336,7 +5482,7 @@ func (m *PauseRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -5351,11 +5497,11 @@ func (m *PauseRequest) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ID = string(data[iNdEx:postIndex]) + m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -5374,8 +5520,8 @@ func (m *PauseRequest) Unmarshal(data []byte) error { } return nil } -func (m *PauseResponse) Unmarshal(data []byte) error { - l := len(data) +func (m *PauseResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -5387,7 +5533,7 @@ func (m *PauseResponse) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -5405,7 +5551,7 @@ func (m *PauseResponse) Unmarshal(data []byte) error { switch fieldNum { default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -5424,8 +5570,8 @@ func (m *PauseResponse) Unmarshal(data []byte) error { } return nil } -func (m *ResumeRequest) Unmarshal(data []byte) error { - l := len(data) +func (m *ResumeRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -5437,7 +5583,7 @@ func (m *ResumeRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -5465,7 +5611,7 @@ func (m *ResumeRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -5480,11 +5626,11 @@ func (m *ResumeRequest) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ID = string(data[iNdEx:postIndex]) + m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -5503,8 +5649,8 @@ func (m *ResumeRequest) Unmarshal(data []byte) error { } return nil } -func (m *ResumeResponse) Unmarshal(data []byte) error { - l := len(data) +func (m *ResumeResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -5516,7 +5662,7 @@ func (m *ResumeResponse) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -5534,7 +5680,7 @@ func (m *ResumeResponse) Unmarshal(data []byte) error { switch fieldNum { default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -5553,8 +5699,8 @@ func (m *ResumeResponse) Unmarshal(data []byte) error { } return nil } -func (m *CreateProcessRequest) Unmarshal(data []byte) error { - l := len(data) +func (m *CreateProcessRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -5566,7 +5712,7 @@ func (m *CreateProcessRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -5594,7 +5740,7 @@ func (m *CreateProcessRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -5609,7 +5755,7 @@ func (m *CreateProcessRequest) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ID = string(data[iNdEx:postIndex]) + m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { @@ -5623,7 +5769,7 @@ func (m *CreateProcessRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { @@ -5640,13 +5786,13 @@ func (m *CreateProcessRequest) Unmarshal(data []byte) error { if m.Spec == nil { m.Spec = &ProcessSpec{} } - if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil { + if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -5665,8 +5811,8 @@ func (m *CreateProcessRequest) Unmarshal(data []byte) error { } return nil } -func (m *CreateProcessResponse) Unmarshal(data []byte) error { - l := len(data) +func (m *CreateProcessResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -5678,7 +5824,7 @@ func (m *CreateProcessResponse) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -5696,7 +5842,7 @@ func (m *CreateProcessResponse) Unmarshal(data []byte) error { switch fieldNum { default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -5715,8 +5861,8 @@ func (m *CreateProcessResponse) Unmarshal(data []byte) error { } return nil } -func (m *StartProcessRequest) Unmarshal(data []byte) error { - l := len(data) +func (m *StartProcessRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -5728,7 +5874,7 @@ func (m *StartProcessRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -5756,7 +5902,7 @@ func (m *StartProcessRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -5771,7 +5917,7 @@ func (m *StartProcessRequest) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Cid = string(data[iNdEx:postIndex]) + m.Cid = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { @@ -5785,7 +5931,7 @@ func (m *StartProcessRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -5800,11 +5946,11 @@ func (m *StartProcessRequest) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Pid = string(data[iNdEx:postIndex]) + m.Pid = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -5823,8 +5969,8 @@ func (m *StartProcessRequest) Unmarshal(data []byte) error { } return nil } -func (m *StartProcessResponse) Unmarshal(data []byte) error { - l := len(data) +func (m *StartProcessResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -5836,7 +5982,7 @@ func (m *StartProcessResponse) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -5864,7 +6010,7 @@ func (m *StartProcessResponse) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ m.Pid |= (uint32(b) & 0x7F) << shift if b < 0x80 { @@ -5873,7 +6019,7 @@ func (m *StartProcessResponse) Unmarshal(data []byte) error { } default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -5892,8 +6038,8 @@ func (m *StartProcessResponse) Unmarshal(data []byte) error { } return nil } -func (m *ProcessStateRequest) Unmarshal(data []byte) error { - l := len(data) +func (m *ProcessStateRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -5905,7 +6051,7 @@ func (m *ProcessStateRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -5933,7 +6079,7 @@ func (m *ProcessStateRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -5948,7 +6094,7 @@ func (m *ProcessStateRequest) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Cid = string(data[iNdEx:postIndex]) + m.Cid = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { @@ -5962,7 +6108,7 @@ func (m *ProcessStateRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -5977,11 +6123,11 @@ func (m *ProcessStateRequest) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Pid = string(data[iNdEx:postIndex]) + m.Pid = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -6000,8 +6146,8 @@ func (m *ProcessStateRequest) Unmarshal(data []byte) error { } return nil } -func (m *ProcessStateResponse) Unmarshal(data []byte) error { - l := len(data) +func (m *ProcessStateResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -6013,7 +6159,7 @@ func (m *ProcessStateResponse) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -6041,7 +6187,7 @@ func (m *ProcessStateResponse) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { @@ -6058,13 +6204,13 @@ func (m *ProcessStateResponse) Unmarshal(data []byte) error { if m.State == nil { m.State = &State{} } - if err := m.State.Unmarshal(data[iNdEx:postIndex]); err != nil { + if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -6083,8 +6229,8 @@ func (m *ProcessStateResponse) Unmarshal(data []byte) error { } return nil } -func (m *SignalProcessRequest) Unmarshal(data []byte) error { - l := len(data) +func (m *SignalProcessRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -6096,7 +6242,7 @@ func (m *SignalProcessRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -6124,7 +6270,7 @@ func (m *SignalProcessRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -6139,7 +6285,7 @@ func (m *SignalProcessRequest) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Cid = string(data[iNdEx:postIndex]) + m.Cid = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { @@ -6153,7 +6299,7 @@ func (m *SignalProcessRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -6168,7 +6314,7 @@ func (m *SignalProcessRequest) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Pid = string(data[iNdEx:postIndex]) + m.Pid = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 0 { @@ -6182,7 +6328,7 @@ func (m *SignalProcessRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ m.Signal |= (uint32(b) & 0x7F) << shift if b < 0x80 { @@ -6191,7 +6337,7 @@ func (m *SignalProcessRequest) Unmarshal(data []byte) error { } default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -6210,8 +6356,8 @@ func (m *SignalProcessRequest) Unmarshal(data []byte) error { } return nil } -func (m *SignalProcessResponse) Unmarshal(data []byte) error { - l := len(data) +func (m *SignalProcessResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -6223,7 +6369,7 @@ func (m *SignalProcessResponse) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -6241,7 +6387,7 @@ func (m *SignalProcessResponse) Unmarshal(data []byte) error { switch fieldNum { default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -6260,8 +6406,8 @@ func (m *SignalProcessResponse) Unmarshal(data []byte) error { } return nil } -func (m *DeleteProcessRequest) Unmarshal(data []byte) error { - l := len(data) +func (m *DeleteProcessRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -6273,7 +6419,7 @@ func (m *DeleteProcessRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -6301,7 +6447,7 @@ func (m *DeleteProcessRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -6316,7 +6462,7 @@ func (m *DeleteProcessRequest) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Cid = string(data[iNdEx:postIndex]) + m.Cid = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { @@ -6330,7 +6476,7 @@ func (m *DeleteProcessRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -6345,11 +6491,11 @@ func (m *DeleteProcessRequest) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Pid = string(data[iNdEx:postIndex]) + m.Pid = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -6368,8 +6514,8 @@ func (m *DeleteProcessRequest) Unmarshal(data []byte) error { } return nil } -func (m *DeleteProcessResponse) Unmarshal(data []byte) error { - l := len(data) +func (m *DeleteProcessResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -6381,7 +6527,7 @@ func (m *DeleteProcessResponse) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -6399,7 +6545,7 @@ func (m *DeleteProcessResponse) Unmarshal(data []byte) error { switch fieldNum { default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -6418,8 +6564,8 @@ func (m *DeleteProcessResponse) Unmarshal(data []byte) error { } return nil } -func (m *ProcessListRequest) Unmarshal(data []byte) error { - l := len(data) +func (m *ProcessListRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -6431,7 +6577,7 @@ func (m *ProcessListRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -6459,7 +6605,7 @@ func (m *ProcessListRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -6474,11 +6620,11 @@ func (m *ProcessListRequest) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ID = string(data[iNdEx:postIndex]) + m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -6497,8 +6643,8 @@ func (m *ProcessListRequest) Unmarshal(data []byte) error { } return nil } -func (m *ProcessListResponse) Unmarshal(data []byte) error { - l := len(data) +func (m *ProcessListResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -6510,7 +6656,7 @@ func (m *ProcessListResponse) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -6528,7 +6674,7 @@ func (m *ProcessListResponse) Unmarshal(data []byte) error { switch fieldNum { default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -6547,8 +6693,8 @@ func (m *ProcessListResponse) Unmarshal(data []byte) error { } return nil } -func (m *EventsRequest) Unmarshal(data []byte) error { - l := len(data) +func (m *EventsRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -6560,7 +6706,7 @@ func (m *EventsRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -6578,7 +6724,7 @@ func (m *EventsRequest) Unmarshal(data []byte) error { switch fieldNum { default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -6597,8 +6743,8 @@ func (m *EventsRequest) Unmarshal(data []byte) error { } return nil } -func (m *EventsResponse) Unmarshal(data []byte) error { - l := len(data) +func (m *EventsResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -6610,7 +6756,7 @@ func (m *EventsResponse) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -6628,7 +6774,7 @@ func (m *EventsResponse) Unmarshal(data []byte) error { switch fieldNum { default: iNdEx = preIndex - skippy, err := skipContainer(data[iNdEx:]) + skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } @@ -6647,8 +6793,8 @@ func (m *EventsResponse) Unmarshal(data []byte) error { } return nil } -func skipContainer(data []byte) (n int, err error) { - l := len(data) +func skipContainer(dAtA []byte) (n int, err error) { + l := len(dAtA) iNdEx := 0 for iNdEx < l { var wire uint64 @@ -6659,7 +6805,7 @@ func skipContainer(data []byte) (n int, err error) { if iNdEx >= l { return 0, io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -6677,7 +6823,7 @@ func skipContainer(data []byte) (n int, err error) { return 0, io.ErrUnexpectedEOF } iNdEx++ - if data[iNdEx-1] < 0x80 { + if dAtA[iNdEx-1] < 0x80 { break } } @@ -6694,7 +6840,7 @@ func skipContainer(data []byte) (n int, err error) { if iNdEx >= l { return 0, io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { @@ -6717,7 +6863,7 @@ func skipContainer(data []byte) (n int, err error) { if iNdEx >= l { return 0, io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ innerWire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -6728,7 +6874,7 @@ func skipContainer(data []byte) (n int, err error) { if innerWireType == 4 { break } - next, err := skipContainer(data[start:]) + next, err := skipContainer(dAtA[start:]) if err != nil { return 0, err } @@ -6752,71 +6898,74 @@ var ( ErrIntOverflowContainer = fmt.Errorf("proto: integer overflow") ) +func init() { proto.RegisterFile("container.proto", fileDescriptorContainer) } + var fileDescriptorContainer = []byte{ - // 1035 bytes of a gzipped FileDescriptorProto + // 1049 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x57, 0xdd, 0x6e, 0x1b, 0x45, - 0x14, 0x66, 0xfd, 0x1b, 0x1f, 0xb3, 0x69, 0x35, 0x75, 0xcb, 0xca, 0x0d, 0x69, 0x99, 0xa2, 0x36, - 0x42, 0x95, 0x29, 0x01, 0x21, 0x7e, 0xee, 0xd2, 0x56, 0x01, 0x09, 0xa4, 0x30, 0x25, 0x42, 0xe2, - 0x02, 0xb4, 0xd8, 0x83, 0x59, 0x29, 0xf1, 0x2e, 0xbb, 0xeb, 0x54, 0xdc, 0xf1, 0x18, 0xf0, 0x20, - 0xbc, 0x00, 0x57, 0xbd, 0xec, 0x25, 0x57, 0x88, 0xf6, 0x09, 0x78, 0x04, 0xce, 0xfc, 0xec, 0x64, - 0x66, 0x67, 0x1d, 0xbb, 0x11, 0x17, 0x96, 0xce, 0x9c, 0x39, 0x3f, 0xdf, 0x9c, 0x9f, 0x6f, 0x13, - 0xb8, 0x32, 0x4d, 0x17, 0x65, 0x9c, 0x2c, 0x78, 0x3e, 0xc9, 0xf2, 0xb4, 0x4c, 0x49, 0x68, 0x14, - 0xb3, 0xc9, 0xd9, 0x7b, 0xe3, 0xd1, 0x3c, 0x9d, 0xa7, 0xf2, 0xe6, 0x5d, 0x21, 0x29, 0x23, 0xfa, - 0x7b, 0x00, 0x83, 0x87, 0x95, 0x1d, 0xb9, 0x01, 0xad, 0x64, 0x16, 0x05, 0xb7, 0x83, 0xbd, 0xc1, - 0x41, 0xef, 0xe5, 0xdf, 0xb7, 0x5a, 0x9f, 0x3f, 0x62, 0xa8, 0x21, 0xf7, 0xa1, 0x77, 0x9a, 0x2e, - 0x17, 0x65, 0x11, 0xb5, 0x6e, 0xb7, 0xf7, 0x86, 0xfb, 0xa3, 0x89, 0x13, 0x7b, 0xf2, 0xa5, 0xb8, - 0x64, 0xda, 0x86, 0x8c, 0xa0, 0x9b, 0x3e, 0xc5, 0xab, 0xa8, 0x2d, 0x02, 0x31, 0x75, 0x20, 0x0f, - 0xa0, 0x8f, 0x29, 0xa7, 0xbc, 0x28, 0xa2, 0x0e, 0xea, 0x87, 0xfb, 0x37, 0x6a, 0x41, 0x8e, 0xd4, - 0x2d, 0xab, 0xcc, 0xe8, 0x6f, 0x01, 0xf4, 0xb5, 0x92, 0x5c, 0x85, 0x76, 0xa6, 0xa1, 0x75, 0x98, - 0x10, 0x09, 0x81, 0x4e, 0x9c, 0xcf, 0x15, 0xa2, 0x01, 0x93, 0xb2, 0xb0, 0xe2, 0x8b, 0x33, 0xcc, - 0x2b, 0x54, 0x42, 0x24, 0xf7, 0xa0, 0xb3, 0x2c, 0x10, 0x8a, 0x4a, 0x79, 0xad, 0x96, 0xf2, 0x18, - 0xaf, 0x98, 0x34, 0x10, 0xae, 0xd3, 0xa7, 0xb3, 0xa8, 0x2b, 0x21, 0x0b, 0x91, 0x8c, 0x61, 0xab, - 0xe4, 0xf9, 0x69, 0xb2, 0x88, 0x4f, 0xa2, 0x1e, 0xaa, 0xb7, 0x98, 0x39, 0xd3, 0xe7, 0x01, 0x0c, - 0x35, 0xb4, 0x27, 0x19, 0x9f, 0x1a, 0x30, 0x81, 0x0f, 0xa6, 0xe5, 0x83, 0x69, 0x6f, 0x08, 0xa6, - 0xd3, 0x0c, 0xa6, 0xeb, 0x82, 0x11, 0xf5, 0x2e, 0xca, 0x59, 0xb2, 0x90, 0x28, 0xb1, 0xde, 0xf2, - 0x80, 0xbd, 0xec, 0xa1, 0x90, 0x2e, 0xcb, 0xa8, 0x2f, 0xd5, 0xfa, 0xa4, 0xf5, 0x3c, 0xcf, 0xa3, - 0x2d, 0xa3, 0xc7, 0x13, 0xe5, 0xd0, 0x95, 0x6d, 0x94, 0x06, 0xe9, 0x32, 0x9f, 0x72, 0x35, 0x08, - 0x4c, 0x9f, 0x84, 0xbe, 0xc4, 0x87, 0xf1, 0x12, 0x9f, 0x24, 0xf5, 0xea, 0x24, 0xde, 0x5e, 0xfe, - 0x92, 0x71, 0xdd, 0x6d, 0x29, 0x93, 0x08, 0xfa, 0x69, 0x56, 0x26, 0xe9, 0x42, 0x34, 0x5b, 0xbc, - 0xbf, 0x3a, 0x52, 0x06, 0x9d, 0x63, 0xfd, 0xc4, 0xa5, 0x6e, 0x68, 0xc8, 0x84, 0x28, 0x34, 0x73, - 0xd4, 0xb4, 0x94, 0x06, 0x45, 0x72, 0x17, 0xb6, 0xe3, 0xd9, 0x2c, 0x11, 0x8e, 0xf1, 0xc9, 0x61, - 0x32, 0x2b, 0x64, 0x67, 0x43, 0x56, 0xd3, 0xd2, 0x3f, 0x03, 0x08, 0x1f, 0xe6, 0x3c, 0x2e, 0x39, - 0xe3, 0x3f, 0x2f, 0x79, 0x51, 0xae, 0x1c, 0xe4, 0x0f, 0xce, 0x87, 0xb0, 0x25, 0x9b, 0x30, 0x6e, - 0x1e, 0x42, 0xd1, 0x54, 0x33, 0x88, 0xd6, 0xf8, 0xb7, 0x5f, 0x65, 0xfc, 0x3b, 0xf6, 0xf8, 0xdf, - 0x82, 0x21, 0x3a, 0xfd, 0x98, 0xcc, 0xbf, 0xcf, 0xe2, 0xf2, 0x27, 0x3d, 0x67, 0xa0, 0x54, 0x47, - 0xa8, 0xa1, 0x9f, 0xc1, 0x76, 0xf5, 0x86, 0x22, 0xc3, 0x4a, 0x71, 0xf2, 0x21, 0x0c, 0x4c, 0x1e, - 0xf9, 0x96, 0xe1, 0x7e, 0x54, 0xcb, 0x6c, 0x56, 0x97, 0x9d, 0x9b, 0xd2, 0xbb, 0xf0, 0xfa, 0x13, - 0xec, 0x4d, 0xb9, 0xa6, 0x18, 0xb4, 0x0f, 0x5d, 0xb4, 0x2b, 0x39, 0xfd, 0x14, 0x42, 0xed, 0xa0, - 0x33, 0xbf, 0x23, 0x26, 0x0a, 0x6f, 0x74, 0xd6, 0xfa, 0x7b, 0xa5, 0x17, 0x53, 0x26, 0xf4, 0x1e, - 0x84, 0x8f, 0xf8, 0x09, 0x5f, 0x5b, 0x7b, 0x7a, 0x15, 0xb6, 0x2b, 0x43, 0x95, 0x86, 0xde, 0x87, - 0x91, 0x79, 0xc0, 0x17, 0x49, 0x61, 0x00, 0x9b, 0x0a, 0xaa, 0x75, 0x52, 0x07, 0xfa, 0x15, 0x5c, - 0xaf, 0x59, 0x6b, 0xb4, 0x1f, 0x01, 0x18, 0x7c, 0x6a, 0x05, 0x2f, 0x2a, 0x94, 0x65, 0xab, 0x2b, - 0xb5, 0x1e, 0xfa, 0xa1, 0x2c, 0xd0, 0xff, 0xd0, 0x1a, 0x2c, 0xd6, 0x71, 0x36, 0x8b, 0x37, 0x2a, - 0x56, 0x65, 0xa8, 0x8b, 0x85, 0x58, 0x8f, 0x62, 0x64, 0x87, 0x75, 0x9e, 0x57, 0x20, 0xd4, 0x76, - 0xda, 0x11, 0x73, 0xa2, 0xbc, 0x3c, 0xdd, 0x24, 0x67, 0x65, 0xa8, 0x5d, 0xbf, 0xc3, 0x06, 0xc9, - 0x99, 0xac, 0xb8, 0x79, 0xcd, 0x7a, 0x4d, 0xa0, 0x53, 0xe0, 0xe6, 0x6c, 0xb0, 0x5b, 0xd2, 0x8e, - 0xbe, 0x81, 0x2d, 0x75, 0xe3, 0xeb, 0xc4, 0x1f, 0xc3, 0x35, 0x39, 0x91, 0xb5, 0xbc, 0x82, 0x17, - 0xab, 0xc4, 0x4c, 0x88, 0xd5, 0x77, 0x41, 0x31, 0x92, 0x10, 0xe9, 0x1e, 0x8c, 0x5c, 0x57, 0xdd, - 0x32, 0xeb, 0x0b, 0x12, 0x2a, 0x4b, 0x4c, 0x52, 0x41, 0xb2, 0x87, 0x60, 0x93, 0x24, 0x07, 0x30, - 0x72, 0x5d, 0x2f, 0xb1, 0x38, 0x0c, 0x81, 0x26, 0x73, 0xe4, 0xb0, 0x57, 0x7f, 0xa4, 0xe4, 0x68, - 0xe9, 0x2b, 0x59, 0x37, 0x64, 0xfa, 0x24, 0x0a, 0x5a, 0x8b, 0xa9, 0x0b, 0xfa, 0x09, 0x8c, 0xd4, - 0xf2, 0x5d, 0xa2, 0xa2, 0x18, 0xb4, 0xe6, 0x6b, 0xf6, 0x97, 0x68, 0x95, 0xbd, 0xbd, 0xab, 0xc6, - 0xeb, 0xba, 0x29, 0xb7, 0xbd, 0xbd, 0x62, 0x5e, 0x1f, 0x9f, 0x71, 0x24, 0x4e, 0xed, 0x2f, 0xc6, - 0xb0, 0x52, 0x28, 0x93, 0xfd, 0x3f, 0x06, 0x00, 0x66, 0x9d, 0x0a, 0xf2, 0x18, 0x7a, 0x6a, 0x6a, - 0xc8, 0x4e, 0x7d, 0xe7, 0xec, 0x8f, 0xc0, 0xf8, 0xcd, 0x15, 0xb7, 0xba, 0x57, 0x07, 0x92, 0xfe, - 0xf2, 0x92, 0xdc, 0xf4, 0xbb, 0x64, 0xc8, 0x73, 0xbc, 0xd3, 0x7c, 0xa9, 0x63, 0x20, 0x14, 0x55, - 0x1a, 0x0f, 0x8a, 0xc3, 0x89, 0x1e, 0x14, 0x97, 0x08, 0x35, 0x14, 0x8c, 0x72, 0xb3, 0x71, 0x60, - 0x56, 0x43, 0xb1, 0x62, 0x20, 0x14, 0xc5, 0x18, 0x1e, 0x14, 0x87, 0x71, 0x3c, 0x28, 0x2e, 0xcd, - 0x08, 0x28, 0x92, 0x3e, 0x3c, 0x28, 0x36, 0xf9, 0x78, 0x50, 0x1c, 0xc6, 0x11, 0x50, 0x14, 0x91, - 0x78, 0x50, 0x1c, 0x22, 0xf2, 0xa0, 0xb8, 0xec, 0x43, 0xbe, 0xc5, 0xaf, 0xba, 0x4d, 0xf8, 0xe4, - 0xce, 0x2a, 0x8a, 0xb5, 0xc6, 0x6f, 0xfc, 0xf6, 0xc5, 0x46, 0x56, 0x6c, 0x9b, 0x79, 0xfc, 0xd8, - 0x0d, 0xbc, 0xe7, 0xc7, 0x6e, 0x22, 0x2f, 0xf2, 0x8d, 0xfe, 0xfe, 0x56, 0xa1, 0x69, 0xd3, 0x08, - 0xd5, 0x22, 0xdf, 0xb9, 0xd0, 0xe6, 0x3c, 0xb0, 0xcd, 0x3a, 0x5e, 0xe0, 0x06, 0x36, 0xf3, 0x02, - 0x37, 0xd2, 0x16, 0x56, 0xc3, 0xa1, 0x0d, 0xaf, 0x1a, 0x4d, 0x44, 0xe5, 0x55, 0xa3, 0x91, 0x79, - 0x44, 0x6c, 0x87, 0x3d, 0xbc, 0xd8, 0x4d, 0xbc, 0xe4, 0xc5, 0x6e, 0x24, 0x20, 0xf2, 0xb5, 0xf9, - 0x2b, 0x5c, 0xce, 0xc7, 0x5b, 0xcd, 0x6f, 0xb5, 0xa7, 0x83, 0x5e, 0x64, 0xa2, 0xa3, 0x1e, 0x42, - 0x4f, 0x11, 0x90, 0x37, 0xbe, 0x0e, 0x51, 0x79, 0xe3, 0xeb, 0xb2, 0xd6, 0x83, 0xe0, 0x60, 0xe7, - 0xd9, 0x8b, 0xdd, 0xd7, 0xfe, 0xc2, 0xdf, 0xbf, 0x2f, 0x76, 0x83, 0x5f, 0x5f, 0xee, 0x06, 0xcf, - 0xf0, 0xf7, 0x1c, 0x7f, 0xff, 0xe0, 0xef, 0x87, 0x9e, 0xfc, 0x0f, 0xec, 0xfd, 0xff, 0x02, 0x00, - 0x00, 0xff, 0xff, 0x83, 0x90, 0x4d, 0x79, 0xb9, 0x0d, 0x00, 0x00, + 0x14, 0xee, 0xfa, 0x37, 0x3e, 0xee, 0xa6, 0xd5, 0x64, 0x93, 0xae, 0x4c, 0x70, 0xc3, 0x14, 0x25, + 0x16, 0xaa, 0x4c, 0x09, 0x08, 0x51, 0xb8, 0x4b, 0x1b, 0x05, 0x24, 0x90, 0xc2, 0x84, 0x08, 0xa9, + 0x17, 0xa0, 0xc5, 0x3b, 0xb8, 0x2b, 0x25, 0xbb, 0xcb, 0xec, 0x38, 0x15, 0x77, 0x3c, 0x06, 0x3c, + 0x08, 0x2f, 0xc0, 0x55, 0x2f, 0x7b, 0xc9, 0x15, 0x22, 0x7e, 0x02, 0x1e, 0x01, 0xcd, 0xcf, 0xae, + 0x77, 0x76, 0x36, 0xb6, 0x5b, 0xf5, 0x6e, 0xe6, 0xcc, 0x99, 0x73, 0xbe, 0x39, 0xe7, 0x3b, 0xdf, + 0xda, 0x70, 0x67, 0x92, 0xc4, 0x3c, 0x88, 0x62, 0xca, 0xc6, 0x29, 0x4b, 0x78, 0x82, 0xdc, 0xc2, + 0x10, 0x8e, 0xaf, 0x3e, 0x1a, 0x78, 0xd3, 0x64, 0x9a, 0xc8, 0x93, 0x0f, 0xc5, 0x4a, 0x39, 0xe1, + 0x3f, 0x1c, 0xe8, 0x3d, 0xc9, 0xfd, 0xd0, 0x0e, 0x34, 0xa2, 0xd0, 0x77, 0xf6, 0x9c, 0x51, 0xef, + 0xa8, 0x33, 0xff, 0xe7, 0x7e, 0xe3, 0xab, 0xa7, 0xa4, 0x11, 0x85, 0xe8, 0x21, 0x74, 0x2e, 0x93, + 0x59, 0xcc, 0x33, 0xbf, 0xb1, 0xd7, 0x1c, 0xf5, 0x0f, 0xbd, 0xb1, 0x11, 0x7b, 0xfc, 0x8d, 0x38, + 0x24, 0xda, 0x07, 0x79, 0xd0, 0x4e, 0x5e, 0xc4, 0x94, 0xf9, 0x4d, 0x11, 0x88, 0xa8, 0x0d, 0x7a, + 0x04, 0xdd, 0x94, 0x25, 0x13, 0x9a, 0x65, 0x7e, 0x6b, 0xcf, 0x19, 0xf5, 0x0f, 0x77, 0x2a, 0x41, + 0x4e, 0xd5, 0x29, 0xc9, 0xdd, 0xf0, 0xef, 0x0e, 0x74, 0xb5, 0x11, 0xdd, 0x85, 0x66, 0xaa, 0xa1, + 0xb5, 0x88, 0x58, 0x22, 0x04, 0xad, 0x80, 0x4d, 0x15, 0xa2, 0x1e, 0x91, 0x6b, 0xe1, 0x45, 0xe3, + 0x2b, 0xbf, 0x29, 0x4d, 0x62, 0x89, 0x0e, 0xa0, 0x35, 0xcb, 0x28, 0xd3, 0x29, 0xb7, 0x2a, 0x29, + 0xcf, 0x33, 0xca, 0x88, 0x74, 0x10, 0x57, 0x27, 0x2f, 0x42, 0xbf, 0x2d, 0x21, 0x8b, 0x25, 0x1a, + 0xc0, 0x06, 0xa7, 0xec, 0x32, 0x8a, 0x83, 0x0b, 0xbf, 0xb3, 0xe7, 0x8c, 0x36, 0x48, 0xb1, 0xc7, + 0xaf, 0x1c, 0xe8, 0x6b, 0x68, 0x67, 0x29, 0x9d, 0x14, 0x60, 0x1c, 0x1b, 0x4c, 0xc3, 0x06, 0xd3, + 0x5c, 0x13, 0x4c, 0xab, 0x1e, 0x4c, 0xdb, 0x04, 0x23, 0xea, 0x9d, 0xf1, 0x30, 0x8a, 0x25, 0xca, + 0x1e, 0x51, 0x1b, 0xb4, 0x03, 0x9d, 0x8c, 0x87, 0xc9, 0x8c, 0xfb, 0x5d, 0x69, 0xd6, 0x3b, 0x6d, + 0xa7, 0x8c, 0xf9, 0x1b, 0x85, 0x9d, 0x32, 0x86, 0x29, 0xb4, 0x65, 0x1b, 0xa5, 0x43, 0x32, 0x63, + 0x13, 0xaa, 0x88, 0x40, 0xf4, 0x4e, 0xd8, 0x79, 0xc0, 0xa6, 0x94, 0xfb, 0x0d, 0x65, 0x57, 0x3b, + 0xf1, 0x76, 0xfe, 0x6b, 0x4a, 0x75, 0xb7, 0xe5, 0x1a, 0xf9, 0xd0, 0x4d, 0x52, 0x1e, 0x25, 0xb1, + 0x68, 0xb6, 0x78, 0x7f, 0xbe, 0xc5, 0x04, 0x5a, 0xe7, 0xfa, 0x89, 0x33, 0xdd, 0x50, 0x97, 0x88, + 0xa5, 0xb0, 0x4c, 0xa3, 0x50, 0x06, 0x77, 0x89, 0x58, 0xa2, 0x7d, 0xd8, 0x0c, 0xc2, 0x30, 0x12, + 0x17, 0x83, 0x8b, 0x93, 0x28, 0xcc, 0x64, 0x67, 0x5d, 0x52, 0xb1, 0xe2, 0xbf, 0x1c, 0x70, 0x9f, + 0x30, 0x1a, 0x70, 0x4a, 0xe8, 0x2f, 0x33, 0x9a, 0xf1, 0x1b, 0x89, 0xfc, 0xc9, 0x82, 0x84, 0x0d, + 0xd9, 0x84, 0x41, 0x3d, 0x09, 0x45, 0x53, 0x0b, 0x22, 0x96, 0xe8, 0xdf, 0x7c, 0x1d, 0xfa, 0xb7, + 0xca, 0xf4, 0xbf, 0x0f, 0xfd, 0x49, 0x12, 0xff, 0x1c, 0x4d, 0x7f, 0x4c, 0x03, 0xfe, 0x5c, 0xf3, + 0x0c, 0x94, 0xe9, 0x34, 0xe0, 0xcf, 0xf1, 0x97, 0xb0, 0x99, 0xbf, 0x21, 0x4b, 0x93, 0x38, 0xa3, + 0xe8, 0x53, 0xe8, 0x15, 0x79, 0xe4, 0x5b, 0xfa, 0x87, 0x7e, 0x25, 0x73, 0x31, 0xba, 0x64, 0xe1, + 0x8a, 0xf7, 0xe1, 0xf6, 0x19, 0x0f, 0x18, 0x5f, 0x51, 0x0c, 0xdc, 0x85, 0xf6, 0x19, 0x0f, 0x38, + 0xc5, 0x5f, 0x80, 0xab, 0x2f, 0xe8, 0xcc, 0x1f, 0x08, 0x46, 0x05, 0x9c, 0xea, 0xac, 0xd5, 0xf7, + 0xca, 0x5b, 0x44, 0xb9, 0xe0, 0x03, 0x70, 0x9f, 0xd2, 0x0b, 0xba, 0xb2, 0xf6, 0xf8, 0x2e, 0x6c, + 0xe6, 0x8e, 0x2a, 0x0d, 0x7e, 0x08, 0x5e, 0xf1, 0x80, 0xaf, 0xa3, 0xac, 0x00, 0x5c, 0x54, 0x50, + 0x8d, 0x93, 0xda, 0xe0, 0x6f, 0x61, 0xbb, 0xe2, 0xad, 0xd1, 0x7e, 0x06, 0x50, 0xe0, 0x53, 0x23, + 0xb8, 0xac, 0x50, 0x25, 0x5f, 0x5d, 0xa9, 0xd5, 0xd0, 0x4f, 0x64, 0x81, 0xde, 0x42, 0x6b, 0x0e, + 0xc0, 0x3d, 0x4f, 0xc3, 0x60, 0xad, 0x62, 0xe5, 0x8e, 0xba, 0x58, 0xfb, 0x70, 0xfb, 0x34, 0x98, + 0x65, 0x2b, 0x6f, 0xde, 0x01, 0x57, 0xfb, 0xe9, 0x8b, 0x07, 0xe0, 0x12, 0x9a, 0xcd, 0x2e, 0xd7, + 0xc9, 0x99, 0x3b, 0xea, 0xab, 0x3f, 0x80, 0xa7, 0x38, 0x99, 0x6b, 0xf3, 0x8a, 0xf1, 0x1a, 0x43, + 0x2b, 0x4b, 0xe9, 0x64, 0x8d, 0xd9, 0x92, 0x7e, 0xf8, 0x1e, 0x6c, 0x57, 0xe2, 0xeb, 0xc4, 0x8f, + 0x61, 0x4b, 0x32, 0xb2, 0x92, 0x57, 0xe8, 0x62, 0x9e, 0x98, 0x88, 0x65, 0xfe, 0x5d, 0x50, 0x8a, + 0x24, 0x96, 0x78, 0x04, 0x9e, 0x79, 0x55, 0xb7, 0xac, 0xf4, 0x05, 0x71, 0x95, 0xe7, 0x63, 0xd8, + 0xca, 0x21, 0x95, 0x49, 0xb0, 0x4e, 0x92, 0x23, 0xf0, 0xcc, 0xab, 0x6f, 0x30, 0x38, 0x04, 0xbc, + 0xb3, 0x68, 0x1a, 0x07, 0x17, 0xaf, 0xff, 0x48, 0xa9, 0xd1, 0xf2, 0xae, 0x54, 0x5d, 0x97, 0xe8, + 0x9d, 0x28, 0x68, 0x25, 0xa6, 0x2e, 0xe8, 0xe7, 0xe0, 0xa9, 0xe1, 0x7b, 0x83, 0x8a, 0xde, 0x83, + 0xed, 0xca, 0xdd, 0x62, 0x7e, 0x91, 0x36, 0x95, 0xa7, 0xf7, 0x26, 0x7a, 0x6d, 0x17, 0xe5, 0x2e, + 0x4f, 0xaf, 0xe0, 0xeb, 0xf1, 0x15, 0x8d, 0x79, 0x0e, 0x49, 0xd0, 0x30, 0x37, 0x28, 0x97, 0xc3, + 0x3f, 0x7b, 0x00, 0xc5, 0x38, 0x65, 0xe8, 0x18, 0x3a, 0x8a, 0x35, 0x68, 0xb7, 0x3a, 0x73, 0xe5, + 0x8f, 0xc0, 0xe0, 0xdd, 0x1b, 0x4e, 0x75, 0xaf, 0x8e, 0xa4, 0xfc, 0x31, 0x8e, 0xde, 0xb1, 0xbb, + 0x54, 0x88, 0xe7, 0x60, 0xb7, 0xfe, 0x50, 0xc7, 0x38, 0x86, 0x8e, 0x2a, 0x8d, 0x05, 0xc5, 0xd0, + 0x44, 0x0b, 0x8a, 0x29, 0x84, 0x1a, 0x0a, 0xa7, 0x75, 0x50, 0x16, 0x41, 0x76, 0xeb, 0x0f, 0x17, + 0x50, 0x94, 0x62, 0x58, 0x50, 0x0c, 0xc5, 0xb1, 0xa0, 0x98, 0x32, 0x23, 0xa0, 0x48, 0xf9, 0xb0, + 0xa0, 0x94, 0xc5, 0xc7, 0x82, 0x62, 0x28, 0x8e, 0x80, 0xa2, 0x84, 0xc4, 0x82, 0x62, 0x08, 0x91, + 0x05, 0xc5, 0x54, 0x1f, 0xf4, 0x0c, 0x5c, 0x43, 0xf0, 0xd1, 0x83, 0x9b, 0x24, 0xb6, 0x44, 0xbf, + 0xc1, 0xfb, 0xcb, 0x9d, 0x4a, 0xb1, 0xcb, 0xca, 0x63, 0xc7, 0xae, 0xd1, 0x3d, 0x3b, 0x76, 0x9d, + 0x78, 0xa1, 0xef, 0xf5, 0xf7, 0x37, 0x0f, 0x8d, 0xeb, 0x28, 0x54, 0x89, 0xfc, 0x60, 0xa9, 0xcf, + 0x22, 0x70, 0x59, 0x75, 0xac, 0xc0, 0x35, 0x6a, 0x66, 0x05, 0xae, 0x95, 0xad, 0x67, 0xe0, 0x1a, + 0xb2, 0x61, 0x55, 0xa3, 0x4e, 0xa8, 0xac, 0x6a, 0xd4, 0x2a, 0x8f, 0x88, 0x6d, 0xa8, 0x87, 0x15, + 0xbb, 0x4e, 0x97, 0xac, 0xd8, 0xb5, 0x02, 0x84, 0xbe, 0x2b, 0x7e, 0x85, 0x4b, 0x7e, 0xbc, 0x57, + 0xff, 0xd6, 0x32, 0x3b, 0xf0, 0x32, 0x17, 0x1d, 0xf5, 0x04, 0x3a, 0x4a, 0x80, 0x2c, 0xfa, 0x1a, + 0x42, 0x65, 0xd1, 0xd7, 0x54, 0xad, 0x47, 0xce, 0xd1, 0xee, 0xcb, 0xeb, 0xe1, 0xad, 0xbf, 0xaf, + 0x87, 0xb7, 0xfe, 0xbb, 0x1e, 0x3a, 0xbf, 0xcd, 0x87, 0xce, 0xcb, 0xf9, 0xd0, 0x79, 0x35, 0x1f, + 0x3a, 0xff, 0xce, 0x87, 0xce, 0x4f, 0x1d, 0xf9, 0x0f, 0xec, 0xe3, 0xff, 0x03, 0x00, 0x00, 0xff, + 0xff, 0x83, 0x90, 0x4d, 0x79, 0xb9, 0x0d, 0x00, 0x00, } diff --git a/api/container/gen.go b/api/container/gen.go index c64a56bca..74221f9aa 100644 --- a/api/container/gen.go +++ b/api/container/gen.go @@ -1,3 +1,3 @@ package container -//go:generate protoc -I.:../../../../../github.com/gogo/protobuf --gogoswarm_out=plugins=grpc,import_path=github.com/docker/containerd/api/container,Mgogoproto/gogo.proto=github.com/gogo/protobuf/gogoproto,Mgoogle/protobuf/descriptor.proto=github.com/gogo/protobuf/protoc-gen-gogo/descriptor:. container.proto +//go:generate protoc -I.:../../../../../github.com/gogo/protobuf --gogoctrd_out=plugins=grpc,import_path=github.com/docker/containerd/api/container,Mgogoproto/gogo.proto=github.com/gogo/protobuf/gogoproto,Mgoogle/protobuf/descriptor.proto=github.com/gogo/protobuf/protoc-gen-gogo/descriptor:. container.proto diff --git a/api/registry/gen.go b/api/registry/gen.go index dba231c94..49288c83e 100644 --- a/api/registry/gen.go +++ b/api/registry/gen.go @@ -1,3 +1,3 @@ -package container +package registry -//go:generate protoc -I.:../../../../../github.com/gogo/protobuf --gogoswarm_out=plugins=grpc,import_path=github.com/docker/containerd/api/registry,Mgogoproto/gogo.proto=github.com/gogo/protobuf/gogoproto,Mgoogle/protobuf/descriptor.proto=github.com/gogo/protobuf/protoc-gen-gogo/descriptor:. registry.proto +//go:generate protoc -I.:../../../../../github.com/gogo/protobuf --gogoctrd_out=plugins=grpc,import_path=github.com/docker/containerd/api/registry,Mgogoproto/gogo.proto=github.com/gogo/protobuf/gogoproto,Mgoogle/protobuf/descriptor.proto=github.com/gogo/protobuf/protoc-gen-gogo/descriptor:. registry.proto diff --git a/api/registry/registry.pb.go b/api/registry/registry.pb.go index 5012d2d91..01a5a995a 100644 --- a/api/registry/registry.pb.go +++ b/api/registry/registry.pb.go @@ -49,7 +49,9 @@ var _ = math.Inf // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. -const _ = proto.GoGoProtoPackageIsVersion1 +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package type PullRequest struct { Uri string `protobuf:"bytes,1,opt,name=uri,proto3" json:"uri,omitempty"` @@ -286,11 +288,12 @@ func valueToGoStringRegistry(v interface{}, typ string) string { pv := reflect.Indirect(rv).Interface() return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) } -func extensionToGoStringRegistry(e map[int32]github_com_gogo_protobuf_proto.Extension) string { +func extensionToGoStringRegistry(m github_com_gogo_protobuf_proto.Message) string { + e := github_com_gogo_protobuf_proto.GetUnsafeExtensionsMap(m) if e == nil { return "nil" } - s := "map[int32]proto.Extension{" + s := "proto.NewUnsafeXXX_InternalExtensions(map[int32]proto.Extension{" keys := make([]int, 0, len(e)) for k := range e { keys = append(keys, int(k)) @@ -300,7 +303,7 @@ func extensionToGoStringRegistry(e map[int32]github_com_gogo_protobuf_proto.Exte for _, k := range keys { ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) } - s += strings.Join(ss, ",") + "}" + s += strings.Join(ss, ",") + "})" return s } @@ -308,6 +311,10 @@ func extensionToGoStringRegistry(e map[int32]github_com_gogo_protobuf_proto.Exte var _ context.Context var _ grpc.ClientConn +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + // Client API for Registry service type RegistryClient interface { @@ -418,40 +425,58 @@ func RegisterRegistryServer(s *grpc.Server, srv RegistryServer) { s.RegisterService(&_Registry_serviceDesc, srv) } -func _Registry_Pull_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) { +func _Registry_Pull_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(PullRequest) if err := dec(in); err != nil { return nil, err } - out, err := srv.(RegistryServer).Pull(ctx, in) - if err != nil { - return nil, err + if interceptor == nil { + return srv.(RegistryServer).Pull(ctx, in) } - return out, nil + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.v1.Registry/Pull", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(RegistryServer).Pull(ctx, req.(*PullRequest)) + } + return interceptor(ctx, in, info, handler) } -func _Registry_Push_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) { +func _Registry_Push_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(PushRequest) if err := dec(in); err != nil { return nil, err } - out, err := srv.(RegistryServer).Push(ctx, in) - if err != nil { - return nil, err + if interceptor == nil { + return srv.(RegistryServer).Push(ctx, in) } - return out, nil + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.v1.Registry/Push", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(RegistryServer).Push(ctx, req.(*PushRequest)) + } + return interceptor(ctx, in, info, handler) } -func _Registry_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) { +func _Registry_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(DeleteRequest) if err := dec(in); err != nil { return nil, err } - out, err := srv.(RegistryServer).Delete(ctx, in) - if err != nil { - return nil, err + if interceptor == nil { + return srv.(RegistryServer).Delete(ctx, in) } - return out, nil + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.v1.Registry/Delete", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(RegistryServer).Delete(ctx, req.(*DeleteRequest)) + } + return interceptor(ctx, in, info, handler) } func _Registry_Status_Handler(srv interface{}, stream grpc.ServerStream) error { @@ -475,16 +500,22 @@ func (x *registryStatusServer) Send(m *StatusResponse) error { return x.ServerStream.SendMsg(m) } -func _Registry_Cancel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) { +func _Registry_Cancel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(CancelRequest) if err := dec(in); err != nil { return nil, err } - out, err := srv.(RegistryServer).Cancel(ctx, in) - if err != nil { - return nil, err + if interceptor == nil { + return srv.(RegistryServer).Cancel(ctx, in) } - return out, nil + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.v1.Registry/Cancel", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(RegistryServer).Cancel(ctx, req.(*CancelRequest)) + } + return interceptor(ctx, in, info, handler) } var _Registry_serviceDesc = grpc.ServiceDesc{ @@ -515,34 +546,35 @@ var _Registry_serviceDesc = grpc.ServiceDesc{ ServerStreams: true, }, }, + Metadata: "registry.proto", } -func (m *PullRequest) Marshal() (data []byte, err error) { +func (m *PullRequest) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *PullRequest) MarshalTo(data []byte) (int, error) { +func (m *PullRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Uri) > 0 { - data[i] = 0xa + dAtA[i] = 0xa i++ - i = encodeVarintRegistry(data, i, uint64(len(m.Uri))) - i += copy(data[i:], m.Uri) + i = encodeVarintRegistry(dAtA, i, uint64(len(m.Uri))) + i += copy(dAtA[i:], m.Uri) } if m.Auth != nil { - data[i] = 0x12 + dAtA[i] = 0x12 i++ - i = encodeVarintRegistry(data, i, uint64(m.Auth.Size())) - n1, err := m.Auth.MarshalTo(data[i:]) + i = encodeVarintRegistry(dAtA, i, uint64(m.Auth.Size())) + n1, err := m.Auth.MarshalTo(dAtA[i:]) if err != nil { return 0, err } @@ -551,33 +583,33 @@ func (m *PullRequest) MarshalTo(data []byte) (int, error) { return i, nil } -func (m *PullResponse) Marshal() (data []byte, err error) { +func (m *PullResponse) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *PullResponse) MarshalTo(data []byte) (int, error) { +func (m *PullResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.ID) > 0 { - data[i] = 0xa + dAtA[i] = 0xa i++ - i = encodeVarintRegistry(data, i, uint64(len(m.ID))) - i += copy(data[i:], m.ID) + i = encodeVarintRegistry(dAtA, i, uint64(len(m.ID))) + i += copy(dAtA[i:], m.ID) } if len(m.Layers) > 0 { for _, msg := range m.Layers { - data[i] = 0x12 + dAtA[i] = 0x12 i++ - i = encodeVarintRegistry(data, i, uint64(msg.Size())) - n, err := msg.MarshalTo(data[i:]) + i = encodeVarintRegistry(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } @@ -587,17 +619,17 @@ func (m *PullResponse) MarshalTo(data []byte) (int, error) { return i, nil } -func (m *PushRequest) Marshal() (data []byte, err error) { +func (m *PushRequest) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *PushRequest) MarshalTo(data []byte) (int, error) { +func (m *PushRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int @@ -605,17 +637,17 @@ func (m *PushRequest) MarshalTo(data []byte) (int, error) { return i, nil } -func (m *PushResponse) Marshal() (data []byte, err error) { +func (m *PushResponse) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *PushResponse) MarshalTo(data []byte) (int, error) { +func (m *PushResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int @@ -623,17 +655,17 @@ func (m *PushResponse) MarshalTo(data []byte) (int, error) { return i, nil } -func (m *StatusRequest) Marshal() (data []byte, err error) { +func (m *StatusRequest) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *StatusRequest) MarshalTo(data []byte) (int, error) { +func (m *StatusRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int @@ -641,17 +673,17 @@ func (m *StatusRequest) MarshalTo(data []byte) (int, error) { return i, nil } -func (m *StatusResponse) Marshal() (data []byte, err error) { +func (m *StatusResponse) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *StatusResponse) MarshalTo(data []byte) (int, error) { +func (m *StatusResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int @@ -659,17 +691,17 @@ func (m *StatusResponse) MarshalTo(data []byte) (int, error) { return i, nil } -func (m *DeleteRequest) Marshal() (data []byte, err error) { +func (m *DeleteRequest) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *DeleteRequest) MarshalTo(data []byte) (int, error) { +func (m *DeleteRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int @@ -677,17 +709,17 @@ func (m *DeleteRequest) MarshalTo(data []byte) (int, error) { return i, nil } -func (m *DeleteResponse) Marshal() (data []byte, err error) { +func (m *DeleteResponse) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *DeleteResponse) MarshalTo(data []byte) (int, error) { +func (m *DeleteResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int @@ -695,17 +727,17 @@ func (m *DeleteResponse) MarshalTo(data []byte) (int, error) { return i, nil } -func (m *CancelRequest) Marshal() (data []byte, err error) { +func (m *CancelRequest) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *CancelRequest) MarshalTo(data []byte) (int, error) { +func (m *CancelRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int @@ -713,17 +745,17 @@ func (m *CancelRequest) MarshalTo(data []byte) (int, error) { return i, nil } -func (m *CancelResponse) Marshal() (data []byte, err error) { +func (m *CancelResponse) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *CancelResponse) MarshalTo(data []byte) (int, error) { +func (m *CancelResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int @@ -731,90 +763,90 @@ func (m *CancelResponse) MarshalTo(data []byte) (int, error) { return i, nil } -func (m *Layer) Marshal() (data []byte, err error) { +func (m *Layer) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *Layer) MarshalTo(data []byte) (int, error) { +func (m *Layer) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.ID) > 0 { - data[i] = 0xa + dAtA[i] = 0xa i++ - i = encodeVarintRegistry(data, i, uint64(len(m.ID))) - i += copy(data[i:], m.ID) + i = encodeVarintRegistry(dAtA, i, uint64(len(m.ID))) + i += copy(dAtA[i:], m.ID) } if m.Size_ != 0 { - data[i] = 0x10 + dAtA[i] = 0x10 i++ - i = encodeVarintRegistry(data, i, uint64(m.Size_)) + i = encodeVarintRegistry(dAtA, i, uint64(m.Size_)) } return i, nil } -func (m *Authentication) Marshal() (data []byte, err error) { +func (m *Authentication) Marshal() (dAtA []byte, err error) { size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } - return data[:n], nil + return dAtA[:n], nil } -func (m *Authentication) MarshalTo(data []byte) (int, error) { +func (m *Authentication) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Username) > 0 { - data[i] = 0xa + dAtA[i] = 0xa i++ - i = encodeVarintRegistry(data, i, uint64(len(m.Username))) - i += copy(data[i:], m.Username) + i = encodeVarintRegistry(dAtA, i, uint64(len(m.Username))) + i += copy(dAtA[i:], m.Username) } if len(m.Password) > 0 { - data[i] = 0x12 + dAtA[i] = 0x12 i++ - i = encodeVarintRegistry(data, i, uint64(len(m.Password))) - i += copy(data[i:], m.Password) + i = encodeVarintRegistry(dAtA, i, uint64(len(m.Password))) + i += copy(dAtA[i:], m.Password) } return i, nil } -func encodeFixed64Registry(data []byte, offset int, v uint64) int { - data[offset] = uint8(v) - data[offset+1] = uint8(v >> 8) - data[offset+2] = uint8(v >> 16) - data[offset+3] = uint8(v >> 24) - data[offset+4] = uint8(v >> 32) - data[offset+5] = uint8(v >> 40) - data[offset+6] = uint8(v >> 48) - data[offset+7] = uint8(v >> 56) +func encodeFixed64Registry(dAtA []byte, offset int, v uint64) int { + dAtA[offset] = uint8(v) + dAtA[offset+1] = uint8(v >> 8) + dAtA[offset+2] = uint8(v >> 16) + dAtA[offset+3] = uint8(v >> 24) + dAtA[offset+4] = uint8(v >> 32) + dAtA[offset+5] = uint8(v >> 40) + dAtA[offset+6] = uint8(v >> 48) + dAtA[offset+7] = uint8(v >> 56) return offset + 8 } -func encodeFixed32Registry(data []byte, offset int, v uint32) int { - data[offset] = uint8(v) - data[offset+1] = uint8(v >> 8) - data[offset+2] = uint8(v >> 16) - data[offset+3] = uint8(v >> 24) +func encodeFixed32Registry(dAtA []byte, offset int, v uint32) int { + dAtA[offset] = uint8(v) + dAtA[offset+1] = uint8(v >> 8) + dAtA[offset+2] = uint8(v >> 16) + dAtA[offset+3] = uint8(v >> 24) return offset + 4 } -func encodeVarintRegistry(data []byte, offset int, v uint64) int { +func encodeVarintRegistry(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { - data[offset] = uint8(v&0x7f | 0x80) + dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } - data[offset] = uint8(v) + dAtA[offset] = uint8(v) return offset + 1 } func (m *PullRequest) Size() (n int) { @@ -1059,8 +1091,8 @@ func valueToStringRegistry(v interface{}) string { pv := reflect.Indirect(rv).Interface() return fmt.Sprintf("*%v", pv) } -func (m *PullRequest) Unmarshal(data []byte) error { - l := len(data) +func (m *PullRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -1072,7 +1104,7 @@ func (m *PullRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -1100,7 +1132,7 @@ func (m *PullRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -1115,7 +1147,7 @@ func (m *PullRequest) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Uri = string(data[iNdEx:postIndex]) + m.Uri = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { @@ -1129,7 +1161,7 @@ func (m *PullRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { @@ -1146,13 +1178,13 @@ func (m *PullRequest) Unmarshal(data []byte) error { if m.Auth == nil { m.Auth = &Authentication{} } - if err := m.Auth.Unmarshal(data[iNdEx:postIndex]); err != nil { + if err := m.Auth.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex - skippy, err := skipRegistry(data[iNdEx:]) + skippy, err := skipRegistry(dAtA[iNdEx:]) if err != nil { return err } @@ -1171,8 +1203,8 @@ func (m *PullRequest) Unmarshal(data []byte) error { } return nil } -func (m *PullResponse) Unmarshal(data []byte) error { - l := len(data) +func (m *PullResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -1184,7 +1216,7 @@ func (m *PullResponse) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -1212,7 +1244,7 @@ func (m *PullResponse) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -1227,7 +1259,7 @@ func (m *PullResponse) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ID = string(data[iNdEx:postIndex]) + m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { @@ -1241,7 +1273,7 @@ func (m *PullResponse) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { @@ -1256,13 +1288,13 @@ func (m *PullResponse) Unmarshal(data []byte) error { return io.ErrUnexpectedEOF } m.Layers = append(m.Layers, &Layer{}) - if err := m.Layers[len(m.Layers)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + if err := m.Layers[len(m.Layers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex - skippy, err := skipRegistry(data[iNdEx:]) + skippy, err := skipRegistry(dAtA[iNdEx:]) if err != nil { return err } @@ -1281,8 +1313,8 @@ func (m *PullResponse) Unmarshal(data []byte) error { } return nil } -func (m *PushRequest) Unmarshal(data []byte) error { - l := len(data) +func (m *PushRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -1294,7 +1326,7 @@ func (m *PushRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -1312,7 +1344,7 @@ func (m *PushRequest) Unmarshal(data []byte) error { switch fieldNum { default: iNdEx = preIndex - skippy, err := skipRegistry(data[iNdEx:]) + skippy, err := skipRegistry(dAtA[iNdEx:]) if err != nil { return err } @@ -1331,8 +1363,8 @@ func (m *PushRequest) Unmarshal(data []byte) error { } return nil } -func (m *PushResponse) Unmarshal(data []byte) error { - l := len(data) +func (m *PushResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -1344,7 +1376,7 @@ func (m *PushResponse) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -1362,7 +1394,7 @@ func (m *PushResponse) Unmarshal(data []byte) error { switch fieldNum { default: iNdEx = preIndex - skippy, err := skipRegistry(data[iNdEx:]) + skippy, err := skipRegistry(dAtA[iNdEx:]) if err != nil { return err } @@ -1381,8 +1413,8 @@ func (m *PushResponse) Unmarshal(data []byte) error { } return nil } -func (m *StatusRequest) Unmarshal(data []byte) error { - l := len(data) +func (m *StatusRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -1394,7 +1426,7 @@ func (m *StatusRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -1412,7 +1444,7 @@ func (m *StatusRequest) Unmarshal(data []byte) error { switch fieldNum { default: iNdEx = preIndex - skippy, err := skipRegistry(data[iNdEx:]) + skippy, err := skipRegistry(dAtA[iNdEx:]) if err != nil { return err } @@ -1431,8 +1463,8 @@ func (m *StatusRequest) Unmarshal(data []byte) error { } return nil } -func (m *StatusResponse) Unmarshal(data []byte) error { - l := len(data) +func (m *StatusResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -1444,7 +1476,7 @@ func (m *StatusResponse) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -1462,7 +1494,7 @@ func (m *StatusResponse) Unmarshal(data []byte) error { switch fieldNum { default: iNdEx = preIndex - skippy, err := skipRegistry(data[iNdEx:]) + skippy, err := skipRegistry(dAtA[iNdEx:]) if err != nil { return err } @@ -1481,8 +1513,8 @@ func (m *StatusResponse) Unmarshal(data []byte) error { } return nil } -func (m *DeleteRequest) Unmarshal(data []byte) error { - l := len(data) +func (m *DeleteRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -1494,7 +1526,7 @@ func (m *DeleteRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -1512,7 +1544,7 @@ func (m *DeleteRequest) Unmarshal(data []byte) error { switch fieldNum { default: iNdEx = preIndex - skippy, err := skipRegistry(data[iNdEx:]) + skippy, err := skipRegistry(dAtA[iNdEx:]) if err != nil { return err } @@ -1531,8 +1563,8 @@ func (m *DeleteRequest) Unmarshal(data []byte) error { } return nil } -func (m *DeleteResponse) Unmarshal(data []byte) error { - l := len(data) +func (m *DeleteResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -1544,7 +1576,7 @@ func (m *DeleteResponse) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -1562,7 +1594,7 @@ func (m *DeleteResponse) Unmarshal(data []byte) error { switch fieldNum { default: iNdEx = preIndex - skippy, err := skipRegistry(data[iNdEx:]) + skippy, err := skipRegistry(dAtA[iNdEx:]) if err != nil { return err } @@ -1581,8 +1613,8 @@ func (m *DeleteResponse) Unmarshal(data []byte) error { } return nil } -func (m *CancelRequest) Unmarshal(data []byte) error { - l := len(data) +func (m *CancelRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -1594,7 +1626,7 @@ func (m *CancelRequest) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -1612,7 +1644,7 @@ func (m *CancelRequest) Unmarshal(data []byte) error { switch fieldNum { default: iNdEx = preIndex - skippy, err := skipRegistry(data[iNdEx:]) + skippy, err := skipRegistry(dAtA[iNdEx:]) if err != nil { return err } @@ -1631,8 +1663,8 @@ func (m *CancelRequest) Unmarshal(data []byte) error { } return nil } -func (m *CancelResponse) Unmarshal(data []byte) error { - l := len(data) +func (m *CancelResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -1644,7 +1676,7 @@ func (m *CancelResponse) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -1662,7 +1694,7 @@ func (m *CancelResponse) Unmarshal(data []byte) error { switch fieldNum { default: iNdEx = preIndex - skippy, err := skipRegistry(data[iNdEx:]) + skippy, err := skipRegistry(dAtA[iNdEx:]) if err != nil { return err } @@ -1681,8 +1713,8 @@ func (m *CancelResponse) Unmarshal(data []byte) error { } return nil } -func (m *Layer) Unmarshal(data []byte) error { - l := len(data) +func (m *Layer) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -1694,7 +1726,7 @@ func (m *Layer) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -1722,7 +1754,7 @@ func (m *Layer) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -1737,7 +1769,7 @@ func (m *Layer) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ID = string(data[iNdEx:postIndex]) + m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 0 { @@ -1751,7 +1783,7 @@ func (m *Layer) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ m.Size_ |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -1760,7 +1792,7 @@ func (m *Layer) Unmarshal(data []byte) error { } default: iNdEx = preIndex - skippy, err := skipRegistry(data[iNdEx:]) + skippy, err := skipRegistry(dAtA[iNdEx:]) if err != nil { return err } @@ -1779,8 +1811,8 @@ func (m *Layer) Unmarshal(data []byte) error { } return nil } -func (m *Authentication) Unmarshal(data []byte) error { - l := len(data) +func (m *Authentication) Unmarshal(dAtA []byte) error { + l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -1792,7 +1824,7 @@ func (m *Authentication) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -1820,7 +1852,7 @@ func (m *Authentication) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -1835,7 +1867,7 @@ func (m *Authentication) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Username = string(data[iNdEx:postIndex]) + m.Username = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { @@ -1849,7 +1881,7 @@ func (m *Authentication) Unmarshal(data []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ stringLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -1864,11 +1896,11 @@ func (m *Authentication) Unmarshal(data []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Password = string(data[iNdEx:postIndex]) + m.Password = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex - skippy, err := skipRegistry(data[iNdEx:]) + skippy, err := skipRegistry(dAtA[iNdEx:]) if err != nil { return err } @@ -1887,8 +1919,8 @@ func (m *Authentication) Unmarshal(data []byte) error { } return nil } -func skipRegistry(data []byte) (n int, err error) { - l := len(data) +func skipRegistry(dAtA []byte) (n int, err error) { + l := len(dAtA) iNdEx := 0 for iNdEx < l { var wire uint64 @@ -1899,7 +1931,7 @@ func skipRegistry(data []byte) (n int, err error) { if iNdEx >= l { return 0, io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -1917,7 +1949,7 @@ func skipRegistry(data []byte) (n int, err error) { return 0, io.ErrUnexpectedEOF } iNdEx++ - if data[iNdEx-1] < 0x80 { + if dAtA[iNdEx-1] < 0x80 { break } } @@ -1934,7 +1966,7 @@ func skipRegistry(data []byte) (n int, err error) { if iNdEx >= l { return 0, io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { @@ -1957,7 +1989,7 @@ func skipRegistry(data []byte) (n int, err error) { if iNdEx >= l { return 0, io.ErrUnexpectedEOF } - b := data[iNdEx] + b := dAtA[iNdEx] iNdEx++ innerWire |= (uint64(b) & 0x7F) << shift if b < 0x80 { @@ -1968,7 +2000,7 @@ func skipRegistry(data []byte) (n int, err error) { if innerWireType == 4 { break } - next, err := skipRegistry(data[start:]) + next, err := skipRegistry(dAtA[start:]) if err != nil { return 0, err } @@ -1992,33 +2024,35 @@ var ( ErrIntOverflowRegistry = fmt.Errorf("proto: integer overflow") ) +func init() { proto.RegisterFile("registry.proto", fileDescriptorRegistry) } + var fileDescriptorRegistry = []byte{ - // 418 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x74, 0x93, 0xd1, 0x8e, 0xd2, 0x40, - 0x14, 0x86, 0x6d, 0xa9, 0x0d, 0x1e, 0xa4, 0x92, 0x09, 0x31, 0xa4, 0x02, 0x9a, 0x5e, 0x79, 0x61, - 0xaa, 0xc0, 0x03, 0x18, 0x11, 0xa3, 0x26, 0x5e, 0x98, 0xd1, 0x17, 0x18, 0x61, 0x02, 0x4d, 0x6a, - 0x07, 0x67, 0xa6, 0x6e, 0xd8, 0xab, 0x7d, 0x3c, 0x2e, 0xf7, 0x72, 0xaf, 0x36, 0x0b, 0xfb, 0x02, - 0xfb, 0x08, 0x3b, 0x33, 0x6d, 0x81, 0x52, 0xb8, 0x38, 0xc9, 0xcc, 0x39, 0x7f, 0xbe, 0x39, 0xfd, - 0xff, 0x14, 0x3c, 0x4e, 0xe7, 0x91, 0x90, 0x7c, 0x15, 0x2e, 0x39, 0x93, 0x0c, 0x35, 0xa7, 0x2c, - 0x91, 0x24, 0x4a, 0x28, 0x9f, 0x85, 0xff, 0x07, 0x7e, 0x7b, 0xce, 0xe6, 0xcc, 0x4c, 0xde, 0xeb, - 0x53, 0x26, 0x0a, 0x30, 0x34, 0x7e, 0xa6, 0x71, 0x8c, 0xe9, 0xbf, 0x94, 0x0a, 0x89, 0x5a, 0x50, - 0x4b, 0x79, 0xd4, 0xb1, 0xde, 0x58, 0x6f, 0x9f, 0x61, 0x7d, 0x44, 0x03, 0x70, 0x48, 0x2a, 0x17, - 0x1d, 0x5b, 0xb5, 0x1a, 0xc3, 0x5e, 0x58, 0x82, 0x86, 0x9f, 0xd4, 0x88, 0x26, 0x32, 0x9a, 0x12, - 0x19, 0xb1, 0x04, 0x1b, 0x69, 0xf0, 0x1b, 0x9e, 0x67, 0x4c, 0xb1, 0x64, 0x89, 0xa0, 0xe8, 0x25, - 0xd8, 0xd1, 0x2c, 0x63, 0x8e, 0xdd, 0xed, 0xed, 0x6b, 0xfb, 0xfb, 0x04, 0xab, 0x0e, 0x7a, 0x07, - 0x6e, 0x4c, 0x56, 0x94, 0x0b, 0x05, 0xaf, 0x29, 0x78, 0xfb, 0x08, 0xfe, 0x43, 0x0f, 0x71, 0xae, - 0x09, 0x9a, 0x7a, 0x53, 0xb1, 0xc8, 0x37, 0x0d, 0x3c, 0xfd, 0x88, 0xbe, 0x66, 0x8f, 0x04, 0x2f, - 0xa0, 0xf9, 0x4b, 0x12, 0x99, 0x8a, 0x42, 0xd0, 0x02, 0xaf, 0x68, 0xec, 0x25, 0x13, 0x1a, 0x53, - 0x49, 0x0f, 0x24, 0x45, 0x63, 0x2f, 0xf9, 0x4c, 0x92, 0x29, 0x8d, 0x0f, 0x24, 0x45, 0x23, 0x97, - 0x8c, 0xe0, 0xa9, 0x59, 0xec, 0xec, 0x67, 0x21, 0x70, 0x44, 0x74, 0x49, 0x8d, 0x63, 0x0e, 0x36, - 0xe7, 0xe0, 0x1b, 0x78, 0x65, 0xab, 0x90, 0x0f, 0xf5, 0x54, 0x50, 0x9e, 0x90, 0xbf, 0x34, 0xb7, - 0x7b, 0x77, 0xd7, 0xb3, 0x25, 0x11, 0xe2, 0x82, 0xf1, 0x99, 0xa1, 0xa8, 0x59, 0x71, 0x1f, 0xde, - 0xdb, 0x50, 0xc7, 0x79, 0xd0, 0xe8, 0x23, 0x38, 0xda, 0x69, 0xe4, 0x1f, 0x39, 0x77, 0x10, 0xa9, - 0xff, 0xea, 0xe4, 0x2c, 0x8f, 0xc6, 0x00, 0xc4, 0xe2, 0x04, 0x60, 0xe7, 0xf4, 0x09, 0xc0, 0xde, - 0x76, 0xf4, 0x05, 0xdc, 0xcc, 0x42, 0xd4, 0x3d, 0x92, 0x95, 0xac, 0xf6, 0x7b, 0x67, 0xa6, 0x39, - 0xe6, 0x2b, 0xb8, 0x59, 0x58, 0x15, 0x4c, 0x29, 0xd4, 0x0a, 0xa6, 0x9c, 0xf0, 0x07, 0x4b, 0xef, - 0x93, 0xe5, 0x55, 0x01, 0x95, 0x72, 0xad, 0x80, 0xca, 0x21, 0x8f, 0xbb, 0xeb, 0x4d, 0xff, 0xc9, - 0x8d, 0xaa, 0x87, 0x4d, 0xdf, 0xba, 0xda, 0xf6, 0xad, 0xb5, 0xaa, 0x6b, 0x55, 0x77, 0xaa, 0xfe, - 0xb8, 0xe6, 0xdf, 0x19, 0x3d, 0x06, 0x00, 0x00, 0xff, 0xff, 0x1d, 0xe2, 0x86, 0x58, 0x72, 0x03, - 0x00, 0x00, + // 424 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x74, 0x93, 0x4f, 0x8e, 0xd3, 0x30, + 0x14, 0xc6, 0xc7, 0x99, 0x10, 0xcd, 0xbc, 0xd2, 0x30, 0xb2, 0x46, 0xa8, 0x0a, 0x33, 0xa1, 0xca, + 0xaa, 0x0b, 0x14, 0x98, 0xf6, 0x00, 0x88, 0x52, 0x04, 0x48, 0x2c, 0x90, 0xe1, 0x02, 0xa6, 0xb1, + 0x1a, 0x4b, 0x21, 0x2e, 0xb6, 0x03, 0x2a, 0x2b, 0x8e, 0xd7, 0x25, 0x4b, 0x56, 0x88, 0x86, 0x0b, + 0x70, 0x04, 0x64, 0x27, 0x69, 0x9b, 0xa6, 0xdd, 0xbd, 0x3f, 0x9f, 0x7e, 0x7e, 0xf9, 0x3e, 0x05, + 0x7c, 0xc9, 0x16, 0x5c, 0x69, 0xb9, 0x8a, 0x97, 0x52, 0x68, 0x81, 0xfb, 0x73, 0x91, 0x6b, 0xca, + 0x73, 0x26, 0x93, 0xf8, 0xeb, 0x5d, 0x70, 0xbd, 0x10, 0x0b, 0x61, 0x37, 0x4f, 0x4d, 0x55, 0x89, + 0x22, 0x02, 0xbd, 0xf7, 0x45, 0x96, 0x11, 0xf6, 0xa5, 0x60, 0x4a, 0xe3, 0x2b, 0x38, 0x2f, 0x24, + 0x1f, 0xa0, 0x21, 0x1a, 0x5d, 0x12, 0x53, 0xe2, 0x3b, 0x70, 0x69, 0xa1, 0xd3, 0x81, 0x33, 0x44, + 0xa3, 0xde, 0xf8, 0x36, 0x6e, 0x41, 0xe3, 0x17, 0x85, 0x4e, 0x59, 0xae, 0xf9, 0x9c, 0x6a, 0x2e, + 0x72, 0x62, 0xa5, 0xd1, 0x47, 0xb8, 0x5f, 0x31, 0xd5, 0x52, 0xe4, 0x8a, 0xe1, 0x87, 0xe0, 0xf0, + 0xa4, 0x62, 0x4e, 0xbd, 0xf2, 0xf7, 0x63, 0xe7, 0xed, 0x8c, 0x38, 0x3c, 0xc1, 0x4f, 0xc0, 0xcb, + 0xe8, 0x8a, 0x49, 0x35, 0x70, 0x86, 0xe7, 0xa3, 0xde, 0xf8, 0xfa, 0x00, 0xfe, 0xce, 0x2c, 0x49, + 0xad, 0x89, 0xfa, 0xe6, 0x52, 0x95, 0xd6, 0x97, 0x46, 0xbe, 0x79, 0xc4, 0xb4, 0xd5, 0x23, 0xd1, + 0x03, 0xe8, 0x7f, 0xd0, 0x54, 0x17, 0xaa, 0x11, 0x5c, 0x81, 0xdf, 0x0c, 0x76, 0x92, 0x19, 0xcb, + 0x98, 0x66, 0x7b, 0x92, 0x66, 0xb0, 0x93, 0xbc, 0xa4, 0xf9, 0x9c, 0x65, 0x7b, 0x92, 0x66, 0x50, + 0x4b, 0x26, 0x70, 0xcf, 0x1e, 0x76, 0xf2, 0xb3, 0x30, 0xb8, 0x8a, 0x7f, 0x67, 0xd6, 0x31, 0x97, + 0xd8, 0x3a, 0x7a, 0x03, 0x7e, 0xdb, 0x2a, 0x1c, 0xc0, 0x45, 0xa1, 0x98, 0xcc, 0xe9, 0x67, 0x56, + 0xdb, 0xbd, 0xed, 0xcd, 0x6e, 0x49, 0x95, 0xfa, 0x26, 0x64, 0x62, 0x29, 0x97, 0x64, 0xdb, 0x8f, + 0xff, 0x3a, 0x70, 0x41, 0xea, 0xa0, 0xf1, 0x73, 0x70, 0x8d, 0xd3, 0x38, 0x38, 0x70, 0x6e, 0x2f, + 0xd2, 0xe0, 0xd1, 0xd1, 0x5d, 0x1d, 0x8d, 0x05, 0xa8, 0xf4, 0x08, 0x60, 0xeb, 0xf4, 0x11, 0xc0, + 0xce, 0x76, 0xfc, 0x0a, 0xbc, 0xca, 0x42, 0x7c, 0x73, 0x20, 0x6b, 0x59, 0x1d, 0xdc, 0x9e, 0xd8, + 0xd6, 0x98, 0xd7, 0xe0, 0x55, 0x61, 0x75, 0x30, 0xad, 0x50, 0x3b, 0x98, 0x76, 0xc2, 0xcf, 0x90, + 0xb9, 0xa7, 0xca, 0xab, 0x03, 0x6a, 0xe5, 0xda, 0x01, 0xb5, 0x43, 0x9e, 0xde, 0xac, 0x37, 0xe1, + 0xd9, 0xaf, 0x4d, 0x78, 0xf6, 0x6f, 0x13, 0xa2, 0x1f, 0x65, 0x88, 0xd6, 0x65, 0x88, 0x7e, 0x96, + 0x21, 0xfa, 0x53, 0x86, 0xe8, 0x93, 0x67, 0xff, 0x9d, 0xc9, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x1d, 0xe2, 0x86, 0x58, 0x72, 0x03, 0x00, 0x00, }