| // Code generated by protoc-gen-gogo. DO NOT EDIT. |
| // source: ops.proto |
| |
| // Package pb provides the protobuf definition of LLB: low-level builder instruction. |
| // LLB is DAG-structured; Op represents a vertex, and Definition represents a graph. |
| |
| package pb |
| |
| import ( |
| fmt "fmt" |
| _ "github.com/gogo/protobuf/gogoproto" |
| proto "github.com/gogo/protobuf/proto" |
| github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys" |
| github_com_moby_buildkit_util_apicaps "github.com/moby/buildkit/util/apicaps" |
| github_com_opencontainers_go_digest "github.com/opencontainers/go-digest" |
| io "io" |
| math "math" |
| math_bits "math/bits" |
| ) |
| |
| // Reference imports to suppress errors if they are not otherwise used. |
| var _ = proto.Marshal |
| var _ = fmt.Errorf |
| 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. |
| // A compilation error at this line likely means your copy of the |
| // proto package needs to be updated. |
| const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package |
| |
| type NetMode int32 |
| |
| const ( |
| NetMode_UNSET NetMode = 0 |
| NetMode_HOST NetMode = 1 |
| NetMode_NONE NetMode = 2 |
| ) |
| |
| var NetMode_name = map[int32]string{ |
| 0: "UNSET", |
| 1: "HOST", |
| 2: "NONE", |
| } |
| |
| var NetMode_value = map[string]int32{ |
| "UNSET": 0, |
| "HOST": 1, |
| "NONE": 2, |
| } |
| |
| func (x NetMode) String() string { |
| return proto.EnumName(NetMode_name, int32(x)) |
| } |
| |
| func (NetMode) EnumDescriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{0} |
| } |
| |
| type SecurityMode int32 |
| |
| const ( |
| SecurityMode_SANDBOX SecurityMode = 0 |
| SecurityMode_INSECURE SecurityMode = 1 |
| ) |
| |
| var SecurityMode_name = map[int32]string{ |
| 0: "SANDBOX", |
| 1: "INSECURE", |
| } |
| |
| var SecurityMode_value = map[string]int32{ |
| "SANDBOX": 0, |
| "INSECURE": 1, |
| } |
| |
| func (x SecurityMode) String() string { |
| return proto.EnumName(SecurityMode_name, int32(x)) |
| } |
| |
| func (SecurityMode) EnumDescriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{1} |
| } |
| |
| // MountType defines a type of a mount from a supported set |
| type MountType int32 |
| |
| const ( |
| MountType_BIND MountType = 0 |
| MountType_SECRET MountType = 1 |
| MountType_SSH MountType = 2 |
| MountType_CACHE MountType = 3 |
| MountType_TMPFS MountType = 4 |
| ) |
| |
| var MountType_name = map[int32]string{ |
| 0: "BIND", |
| 1: "SECRET", |
| 2: "SSH", |
| 3: "CACHE", |
| 4: "TMPFS", |
| } |
| |
| var MountType_value = map[string]int32{ |
| "BIND": 0, |
| "SECRET": 1, |
| "SSH": 2, |
| "CACHE": 3, |
| "TMPFS": 4, |
| } |
| |
| func (x MountType) String() string { |
| return proto.EnumName(MountType_name, int32(x)) |
| } |
| |
| func (MountType) EnumDescriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{2} |
| } |
| |
| // CacheSharingOpt defines different sharing modes for cache mount |
| type CacheSharingOpt int32 |
| |
| const ( |
| // SHARED cache mount can be used concurrently by multiple writers |
| CacheSharingOpt_SHARED CacheSharingOpt = 0 |
| // PRIVATE creates a new mount if there are multiple writers |
| CacheSharingOpt_PRIVATE CacheSharingOpt = 1 |
| // LOCKED pauses second writer until first one releases the mount |
| CacheSharingOpt_LOCKED CacheSharingOpt = 2 |
| ) |
| |
| var CacheSharingOpt_name = map[int32]string{ |
| 0: "SHARED", |
| 1: "PRIVATE", |
| 2: "LOCKED", |
| } |
| |
| var CacheSharingOpt_value = map[string]int32{ |
| "SHARED": 0, |
| "PRIVATE": 1, |
| "LOCKED": 2, |
| } |
| |
| func (x CacheSharingOpt) String() string { |
| return proto.EnumName(CacheSharingOpt_name, int32(x)) |
| } |
| |
| func (CacheSharingOpt) EnumDescriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{3} |
| } |
| |
| // Op represents a vertex of the LLB DAG. |
| type Op struct { |
| // inputs is a set of input edges. |
| Inputs []*Input `protobuf:"bytes,1,rep,name=inputs,proto3" json:"inputs,omitempty"` |
| // Types that are valid to be assigned to Op: |
| // *Op_Exec |
| // *Op_Source |
| // *Op_File |
| // *Op_Build |
| Op isOp_Op `protobuf_oneof:"op"` |
| Platform *Platform `protobuf:"bytes,10,opt,name=platform,proto3" json:"platform,omitempty"` |
| Constraints *WorkerConstraints `protobuf:"bytes,11,opt,name=constraints,proto3" json:"constraints,omitempty"` |
| } |
| |
| func (m *Op) Reset() { *m = Op{} } |
| func (m *Op) String() string { return proto.CompactTextString(m) } |
| func (*Op) ProtoMessage() {} |
| func (*Op) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{0} |
| } |
| func (m *Op) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *Op) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *Op) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_Op.Merge(m, src) |
| } |
| func (m *Op) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *Op) XXX_DiscardUnknown() { |
| xxx_messageInfo_Op.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_Op proto.InternalMessageInfo |
| |
| type isOp_Op interface { |
| isOp_Op() |
| MarshalTo([]byte) (int, error) |
| Size() int |
| } |
| |
| type Op_Exec struct { |
| Exec *ExecOp `protobuf:"bytes,2,opt,name=exec,proto3,oneof" json:"exec,omitempty"` |
| } |
| type Op_Source struct { |
| Source *SourceOp `protobuf:"bytes,3,opt,name=source,proto3,oneof" json:"source,omitempty"` |
| } |
| type Op_File struct { |
| File *FileOp `protobuf:"bytes,4,opt,name=file,proto3,oneof" json:"file,omitempty"` |
| } |
| type Op_Build struct { |
| Build *BuildOp `protobuf:"bytes,5,opt,name=build,proto3,oneof" json:"build,omitempty"` |
| } |
| |
| func (*Op_Exec) isOp_Op() {} |
| func (*Op_Source) isOp_Op() {} |
| func (*Op_File) isOp_Op() {} |
| func (*Op_Build) isOp_Op() {} |
| |
| func (m *Op) GetOp() isOp_Op { |
| if m != nil { |
| return m.Op |
| } |
| return nil |
| } |
| |
| func (m *Op) GetInputs() []*Input { |
| if m != nil { |
| return m.Inputs |
| } |
| return nil |
| } |
| |
| func (m *Op) GetExec() *ExecOp { |
| if x, ok := m.GetOp().(*Op_Exec); ok { |
| return x.Exec |
| } |
| return nil |
| } |
| |
| func (m *Op) GetSource() *SourceOp { |
| if x, ok := m.GetOp().(*Op_Source); ok { |
| return x.Source |
| } |
| return nil |
| } |
| |
| func (m *Op) GetFile() *FileOp { |
| if x, ok := m.GetOp().(*Op_File); ok { |
| return x.File |
| } |
| return nil |
| } |
| |
| func (m *Op) GetBuild() *BuildOp { |
| if x, ok := m.GetOp().(*Op_Build); ok { |
| return x.Build |
| } |
| return nil |
| } |
| |
| func (m *Op) GetPlatform() *Platform { |
| if m != nil { |
| return m.Platform |
| } |
| return nil |
| } |
| |
| func (m *Op) GetConstraints() *WorkerConstraints { |
| if m != nil { |
| return m.Constraints |
| } |
| return nil |
| } |
| |
| // XXX_OneofWrappers is for the internal use of the proto package. |
| func (*Op) XXX_OneofWrappers() []interface{} { |
| return []interface{}{ |
| (*Op_Exec)(nil), |
| (*Op_Source)(nil), |
| (*Op_File)(nil), |
| (*Op_Build)(nil), |
| } |
| } |
| |
| // Platform is github.com/opencontainers/image-spec/specs-go/v1.Platform |
| type Platform struct { |
| Architecture string `protobuf:"bytes,1,opt,name=Architecture,proto3" json:"Architecture,omitempty"` |
| OS string `protobuf:"bytes,2,opt,name=OS,proto3" json:"OS,omitempty"` |
| Variant string `protobuf:"bytes,3,opt,name=Variant,proto3" json:"Variant,omitempty"` |
| OSVersion string `protobuf:"bytes,4,opt,name=OSVersion,proto3" json:"OSVersion,omitempty"` |
| OSFeatures []string `protobuf:"bytes,5,rep,name=OSFeatures,proto3" json:"OSFeatures,omitempty"` |
| } |
| |
| func (m *Platform) Reset() { *m = Platform{} } |
| func (m *Platform) String() string { return proto.CompactTextString(m) } |
| func (*Platform) ProtoMessage() {} |
| func (*Platform) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{1} |
| } |
| func (m *Platform) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *Platform) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *Platform) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_Platform.Merge(m, src) |
| } |
| func (m *Platform) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *Platform) XXX_DiscardUnknown() { |
| xxx_messageInfo_Platform.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_Platform proto.InternalMessageInfo |
| |
| func (m *Platform) GetArchitecture() string { |
| if m != nil { |
| return m.Architecture |
| } |
| return "" |
| } |
| |
| func (m *Platform) GetOS() string { |
| if m != nil { |
| return m.OS |
| } |
| return "" |
| } |
| |
| func (m *Platform) GetVariant() string { |
| if m != nil { |
| return m.Variant |
| } |
| return "" |
| } |
| |
| func (m *Platform) GetOSVersion() string { |
| if m != nil { |
| return m.OSVersion |
| } |
| return "" |
| } |
| |
| func (m *Platform) GetOSFeatures() []string { |
| if m != nil { |
| return m.OSFeatures |
| } |
| return nil |
| } |
| |
| // Input represents an input edge for an Op. |
| type Input struct { |
| // digest of the marshaled input Op |
| Digest github_com_opencontainers_go_digest.Digest `protobuf:"bytes,1,opt,name=digest,proto3,customtype=github.com/opencontainers/go-digest.Digest" json:"digest"` |
| // output index of the input Op |
| Index OutputIndex `protobuf:"varint,2,opt,name=index,proto3,customtype=OutputIndex" json:"index"` |
| } |
| |
| func (m *Input) Reset() { *m = Input{} } |
| func (m *Input) String() string { return proto.CompactTextString(m) } |
| func (*Input) ProtoMessage() {} |
| func (*Input) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{2} |
| } |
| func (m *Input) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *Input) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *Input) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_Input.Merge(m, src) |
| } |
| func (m *Input) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *Input) XXX_DiscardUnknown() { |
| xxx_messageInfo_Input.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_Input proto.InternalMessageInfo |
| |
| // ExecOp executes a command in a container. |
| type ExecOp struct { |
| Meta *Meta `protobuf:"bytes,1,opt,name=meta,proto3" json:"meta,omitempty"` |
| Mounts []*Mount `protobuf:"bytes,2,rep,name=mounts,proto3" json:"mounts,omitempty"` |
| Network NetMode `protobuf:"varint,3,opt,name=network,proto3,enum=pb.NetMode" json:"network,omitempty"` |
| Security SecurityMode `protobuf:"varint,4,opt,name=security,proto3,enum=pb.SecurityMode" json:"security,omitempty"` |
| } |
| |
| func (m *ExecOp) Reset() { *m = ExecOp{} } |
| func (m *ExecOp) String() string { return proto.CompactTextString(m) } |
| func (*ExecOp) ProtoMessage() {} |
| func (*ExecOp) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{3} |
| } |
| func (m *ExecOp) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *ExecOp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *ExecOp) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_ExecOp.Merge(m, src) |
| } |
| func (m *ExecOp) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *ExecOp) XXX_DiscardUnknown() { |
| xxx_messageInfo_ExecOp.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_ExecOp proto.InternalMessageInfo |
| |
| func (m *ExecOp) GetMeta() *Meta { |
| if m != nil { |
| return m.Meta |
| } |
| return nil |
| } |
| |
| func (m *ExecOp) GetMounts() []*Mount { |
| if m != nil { |
| return m.Mounts |
| } |
| return nil |
| } |
| |
| func (m *ExecOp) GetNetwork() NetMode { |
| if m != nil { |
| return m.Network |
| } |
| return NetMode_UNSET |
| } |
| |
| func (m *ExecOp) GetSecurity() SecurityMode { |
| if m != nil { |
| return m.Security |
| } |
| return SecurityMode_SANDBOX |
| } |
| |
| // Meta is a set of arguments for ExecOp. |
| // Meta is unrelated to LLB metadata. |
| // FIXME: rename (ExecContext? ExecArgs?) |
| type Meta struct { |
| Args []string `protobuf:"bytes,1,rep,name=args,proto3" json:"args,omitempty"` |
| Env []string `protobuf:"bytes,2,rep,name=env,proto3" json:"env,omitempty"` |
| Cwd string `protobuf:"bytes,3,opt,name=cwd,proto3" json:"cwd,omitempty"` |
| User string `protobuf:"bytes,4,opt,name=user,proto3" json:"user,omitempty"` |
| ProxyEnv *ProxyEnv `protobuf:"bytes,5,opt,name=proxy_env,json=proxyEnv,proto3" json:"proxy_env,omitempty"` |
| ExtraHosts []*HostIP `protobuf:"bytes,6,rep,name=extraHosts,proto3" json:"extraHosts,omitempty"` |
| Hostname string `protobuf:"bytes,7,opt,name=hostname,proto3" json:"hostname,omitempty"` |
| } |
| |
| func (m *Meta) Reset() { *m = Meta{} } |
| func (m *Meta) String() string { return proto.CompactTextString(m) } |
| func (*Meta) ProtoMessage() {} |
| func (*Meta) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{4} |
| } |
| func (m *Meta) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *Meta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *Meta) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_Meta.Merge(m, src) |
| } |
| func (m *Meta) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *Meta) XXX_DiscardUnknown() { |
| xxx_messageInfo_Meta.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_Meta proto.InternalMessageInfo |
| |
| func (m *Meta) GetArgs() []string { |
| if m != nil { |
| return m.Args |
| } |
| return nil |
| } |
| |
| func (m *Meta) GetEnv() []string { |
| if m != nil { |
| return m.Env |
| } |
| return nil |
| } |
| |
| func (m *Meta) GetCwd() string { |
| if m != nil { |
| return m.Cwd |
| } |
| return "" |
| } |
| |
| func (m *Meta) GetUser() string { |
| if m != nil { |
| return m.User |
| } |
| return "" |
| } |
| |
| func (m *Meta) GetProxyEnv() *ProxyEnv { |
| if m != nil { |
| return m.ProxyEnv |
| } |
| return nil |
| } |
| |
| func (m *Meta) GetExtraHosts() []*HostIP { |
| if m != nil { |
| return m.ExtraHosts |
| } |
| return nil |
| } |
| |
| func (m *Meta) GetHostname() string { |
| if m != nil { |
| return m.Hostname |
| } |
| return "" |
| } |
| |
| // Mount specifies how to mount an input Op as a filesystem. |
| type Mount struct { |
| Input InputIndex `protobuf:"varint,1,opt,name=input,proto3,customtype=InputIndex" json:"input"` |
| Selector string `protobuf:"bytes,2,opt,name=selector,proto3" json:"selector,omitempty"` |
| Dest string `protobuf:"bytes,3,opt,name=dest,proto3" json:"dest,omitempty"` |
| Output OutputIndex `protobuf:"varint,4,opt,name=output,proto3,customtype=OutputIndex" json:"output"` |
| Readonly bool `protobuf:"varint,5,opt,name=readonly,proto3" json:"readonly,omitempty"` |
| MountType MountType `protobuf:"varint,6,opt,name=mountType,proto3,enum=pb.MountType" json:"mountType,omitempty"` |
| CacheOpt *CacheOpt `protobuf:"bytes,20,opt,name=cacheOpt,proto3" json:"cacheOpt,omitempty"` |
| SecretOpt *SecretOpt `protobuf:"bytes,21,opt,name=secretOpt,proto3" json:"secretOpt,omitempty"` |
| SSHOpt *SSHOpt `protobuf:"bytes,22,opt,name=SSHOpt,proto3" json:"SSHOpt,omitempty"` |
| ResultID string `protobuf:"bytes,23,opt,name=resultID,proto3" json:"resultID,omitempty"` |
| } |
| |
| func (m *Mount) Reset() { *m = Mount{} } |
| func (m *Mount) String() string { return proto.CompactTextString(m) } |
| func (*Mount) ProtoMessage() {} |
| func (*Mount) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{5} |
| } |
| func (m *Mount) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *Mount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *Mount) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_Mount.Merge(m, src) |
| } |
| func (m *Mount) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *Mount) XXX_DiscardUnknown() { |
| xxx_messageInfo_Mount.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_Mount proto.InternalMessageInfo |
| |
| func (m *Mount) GetSelector() string { |
| if m != nil { |
| return m.Selector |
| } |
| return "" |
| } |
| |
| func (m *Mount) GetDest() string { |
| if m != nil { |
| return m.Dest |
| } |
| return "" |
| } |
| |
| func (m *Mount) GetReadonly() bool { |
| if m != nil { |
| return m.Readonly |
| } |
| return false |
| } |
| |
| func (m *Mount) GetMountType() MountType { |
| if m != nil { |
| return m.MountType |
| } |
| return MountType_BIND |
| } |
| |
| func (m *Mount) GetCacheOpt() *CacheOpt { |
| if m != nil { |
| return m.CacheOpt |
| } |
| return nil |
| } |
| |
| func (m *Mount) GetSecretOpt() *SecretOpt { |
| if m != nil { |
| return m.SecretOpt |
| } |
| return nil |
| } |
| |
| func (m *Mount) GetSSHOpt() *SSHOpt { |
| if m != nil { |
| return m.SSHOpt |
| } |
| return nil |
| } |
| |
| func (m *Mount) GetResultID() string { |
| if m != nil { |
| return m.ResultID |
| } |
| return "" |
| } |
| |
| // CacheOpt defines options specific to cache mounts |
| type CacheOpt struct { |
| // ID is an optional namespace for the mount |
| ID string `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"` |
| // Sharing is the sharing mode for the mount |
| Sharing CacheSharingOpt `protobuf:"varint,2,opt,name=sharing,proto3,enum=pb.CacheSharingOpt" json:"sharing,omitempty"` |
| } |
| |
| func (m *CacheOpt) Reset() { *m = CacheOpt{} } |
| func (m *CacheOpt) String() string { return proto.CompactTextString(m) } |
| func (*CacheOpt) ProtoMessage() {} |
| func (*CacheOpt) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{6} |
| } |
| func (m *CacheOpt) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *CacheOpt) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *CacheOpt) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_CacheOpt.Merge(m, src) |
| } |
| func (m *CacheOpt) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *CacheOpt) XXX_DiscardUnknown() { |
| xxx_messageInfo_CacheOpt.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_CacheOpt proto.InternalMessageInfo |
| |
| func (m *CacheOpt) GetID() string { |
| if m != nil { |
| return m.ID |
| } |
| return "" |
| } |
| |
| func (m *CacheOpt) GetSharing() CacheSharingOpt { |
| if m != nil { |
| return m.Sharing |
| } |
| return CacheSharingOpt_SHARED |
| } |
| |
| // SecretOpt defines options describing secret mounts |
| type SecretOpt struct { |
| // ID of secret. Used for quering the value. |
| ID string `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"` |
| // UID of secret file |
| Uid uint32 `protobuf:"varint,2,opt,name=uid,proto3" json:"uid,omitempty"` |
| // GID of secret file |
| Gid uint32 `protobuf:"varint,3,opt,name=gid,proto3" json:"gid,omitempty"` |
| // Mode is the filesystem mode of secret file |
| Mode uint32 `protobuf:"varint,4,opt,name=mode,proto3" json:"mode,omitempty"` |
| // Optional defines if secret value is required. Error is produced |
| // if value is not found and optional is false. |
| Optional bool `protobuf:"varint,5,opt,name=optional,proto3" json:"optional,omitempty"` |
| } |
| |
| func (m *SecretOpt) Reset() { *m = SecretOpt{} } |
| func (m *SecretOpt) String() string { return proto.CompactTextString(m) } |
| func (*SecretOpt) ProtoMessage() {} |
| func (*SecretOpt) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{7} |
| } |
| func (m *SecretOpt) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *SecretOpt) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *SecretOpt) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_SecretOpt.Merge(m, src) |
| } |
| func (m *SecretOpt) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *SecretOpt) XXX_DiscardUnknown() { |
| xxx_messageInfo_SecretOpt.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_SecretOpt proto.InternalMessageInfo |
| |
| func (m *SecretOpt) GetID() string { |
| if m != nil { |
| return m.ID |
| } |
| return "" |
| } |
| |
| func (m *SecretOpt) GetUid() uint32 { |
| if m != nil { |
| return m.Uid |
| } |
| return 0 |
| } |
| |
| func (m *SecretOpt) GetGid() uint32 { |
| if m != nil { |
| return m.Gid |
| } |
| return 0 |
| } |
| |
| func (m *SecretOpt) GetMode() uint32 { |
| if m != nil { |
| return m.Mode |
| } |
| return 0 |
| } |
| |
| func (m *SecretOpt) GetOptional() bool { |
| if m != nil { |
| return m.Optional |
| } |
| return false |
| } |
| |
| // SSHOpt defines options describing secret mounts |
| type SSHOpt struct { |
| // ID of exposed ssh rule. Used for quering the value. |
| ID string `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"` |
| // UID of agent socket |
| Uid uint32 `protobuf:"varint,2,opt,name=uid,proto3" json:"uid,omitempty"` |
| // GID of agent socket |
| Gid uint32 `protobuf:"varint,3,opt,name=gid,proto3" json:"gid,omitempty"` |
| // Mode is the filesystem mode of agent socket |
| Mode uint32 `protobuf:"varint,4,opt,name=mode,proto3" json:"mode,omitempty"` |
| // Optional defines if ssh socket is required. Error is produced |
| // if client does not expose ssh. |
| Optional bool `protobuf:"varint,5,opt,name=optional,proto3" json:"optional,omitempty"` |
| } |
| |
| func (m *SSHOpt) Reset() { *m = SSHOpt{} } |
| func (m *SSHOpt) String() string { return proto.CompactTextString(m) } |
| func (*SSHOpt) ProtoMessage() {} |
| func (*SSHOpt) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{8} |
| } |
| func (m *SSHOpt) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *SSHOpt) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *SSHOpt) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_SSHOpt.Merge(m, src) |
| } |
| func (m *SSHOpt) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *SSHOpt) XXX_DiscardUnknown() { |
| xxx_messageInfo_SSHOpt.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_SSHOpt proto.InternalMessageInfo |
| |
| func (m *SSHOpt) GetID() string { |
| if m != nil { |
| return m.ID |
| } |
| return "" |
| } |
| |
| func (m *SSHOpt) GetUid() uint32 { |
| if m != nil { |
| return m.Uid |
| } |
| return 0 |
| } |
| |
| func (m *SSHOpt) GetGid() uint32 { |
| if m != nil { |
| return m.Gid |
| } |
| return 0 |
| } |
| |
| func (m *SSHOpt) GetMode() uint32 { |
| if m != nil { |
| return m.Mode |
| } |
| return 0 |
| } |
| |
| func (m *SSHOpt) GetOptional() bool { |
| if m != nil { |
| return m.Optional |
| } |
| return false |
| } |
| |
| // SourceOp specifies a source such as build contexts and images. |
| type SourceOp struct { |
| // TODO: use source type or any type instead of URL protocol. |
| // identifier e.g. local://, docker-image://, git://, https://... |
| Identifier string `protobuf:"bytes,1,opt,name=identifier,proto3" json:"identifier,omitempty"` |
| // attrs are defined in attr.go |
| Attrs map[string]string `protobuf:"bytes,2,rep,name=attrs,proto3" json:"attrs,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` |
| } |
| |
| func (m *SourceOp) Reset() { *m = SourceOp{} } |
| func (m *SourceOp) String() string { return proto.CompactTextString(m) } |
| func (*SourceOp) ProtoMessage() {} |
| func (*SourceOp) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{9} |
| } |
| func (m *SourceOp) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *SourceOp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *SourceOp) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_SourceOp.Merge(m, src) |
| } |
| func (m *SourceOp) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *SourceOp) XXX_DiscardUnknown() { |
| xxx_messageInfo_SourceOp.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_SourceOp proto.InternalMessageInfo |
| |
| func (m *SourceOp) GetIdentifier() string { |
| if m != nil { |
| return m.Identifier |
| } |
| return "" |
| } |
| |
| func (m *SourceOp) GetAttrs() map[string]string { |
| if m != nil { |
| return m.Attrs |
| } |
| return nil |
| } |
| |
| // BuildOp is used for nested build invocation. |
| // BuildOp is experimental and can break without backwards compatibility |
| type BuildOp struct { |
| Builder InputIndex `protobuf:"varint,1,opt,name=builder,proto3,customtype=InputIndex" json:"builder"` |
| Inputs map[string]*BuildInput `protobuf:"bytes,2,rep,name=inputs,proto3" json:"inputs,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` |
| Def *Definition `protobuf:"bytes,3,opt,name=def,proto3" json:"def,omitempty"` |
| Attrs map[string]string `protobuf:"bytes,4,rep,name=attrs,proto3" json:"attrs,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` |
| } |
| |
| func (m *BuildOp) Reset() { *m = BuildOp{} } |
| func (m *BuildOp) String() string { return proto.CompactTextString(m) } |
| func (*BuildOp) ProtoMessage() {} |
| func (*BuildOp) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{10} |
| } |
| func (m *BuildOp) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *BuildOp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *BuildOp) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_BuildOp.Merge(m, src) |
| } |
| func (m *BuildOp) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *BuildOp) XXX_DiscardUnknown() { |
| xxx_messageInfo_BuildOp.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_BuildOp proto.InternalMessageInfo |
| |
| func (m *BuildOp) GetInputs() map[string]*BuildInput { |
| if m != nil { |
| return m.Inputs |
| } |
| return nil |
| } |
| |
| func (m *BuildOp) GetDef() *Definition { |
| if m != nil { |
| return m.Def |
| } |
| return nil |
| } |
| |
| func (m *BuildOp) GetAttrs() map[string]string { |
| if m != nil { |
| return m.Attrs |
| } |
| return nil |
| } |
| |
| // BuildInput is used for BuildOp. |
| type BuildInput struct { |
| Input InputIndex `protobuf:"varint,1,opt,name=input,proto3,customtype=InputIndex" json:"input"` |
| } |
| |
| func (m *BuildInput) Reset() { *m = BuildInput{} } |
| func (m *BuildInput) String() string { return proto.CompactTextString(m) } |
| func (*BuildInput) ProtoMessage() {} |
| func (*BuildInput) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{11} |
| } |
| func (m *BuildInput) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *BuildInput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *BuildInput) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_BuildInput.Merge(m, src) |
| } |
| func (m *BuildInput) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *BuildInput) XXX_DiscardUnknown() { |
| xxx_messageInfo_BuildInput.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_BuildInput proto.InternalMessageInfo |
| |
| // OpMetadata is a per-vertex metadata entry, which can be defined for arbitrary Op vertex and overridable on the run time. |
| type OpMetadata struct { |
| // ignore_cache specifies to ignore the cache for this Op. |
| IgnoreCache bool `protobuf:"varint,1,opt,name=ignore_cache,json=ignoreCache,proto3" json:"ignore_cache,omitempty"` |
| // Description can be used for keeping any text fields that builder doesn't parse |
| Description map[string]string `protobuf:"bytes,2,rep,name=description,proto3" json:"description,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` |
| // index 3 reserved for WorkerConstraint in previous versions |
| // WorkerConstraint worker_constraint = 3; |
| ExportCache *ExportCache `protobuf:"bytes,4,opt,name=export_cache,json=exportCache,proto3" json:"export_cache,omitempty"` |
| Caps map[github_com_moby_buildkit_util_apicaps.CapID]bool `protobuf:"bytes,5,rep,name=caps,proto3,castkey=github.com/moby/buildkit/util/apicaps.CapID" json:"caps" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` |
| } |
| |
| func (m *OpMetadata) Reset() { *m = OpMetadata{} } |
| func (m *OpMetadata) String() string { return proto.CompactTextString(m) } |
| func (*OpMetadata) ProtoMessage() {} |
| func (*OpMetadata) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{12} |
| } |
| func (m *OpMetadata) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *OpMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *OpMetadata) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_OpMetadata.Merge(m, src) |
| } |
| func (m *OpMetadata) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *OpMetadata) XXX_DiscardUnknown() { |
| xxx_messageInfo_OpMetadata.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_OpMetadata proto.InternalMessageInfo |
| |
| func (m *OpMetadata) GetIgnoreCache() bool { |
| if m != nil { |
| return m.IgnoreCache |
| } |
| return false |
| } |
| |
| func (m *OpMetadata) GetDescription() map[string]string { |
| if m != nil { |
| return m.Description |
| } |
| return nil |
| } |
| |
| func (m *OpMetadata) GetExportCache() *ExportCache { |
| if m != nil { |
| return m.ExportCache |
| } |
| return nil |
| } |
| |
| func (m *OpMetadata) GetCaps() map[github_com_moby_buildkit_util_apicaps.CapID]bool { |
| if m != nil { |
| return m.Caps |
| } |
| return nil |
| } |
| |
| // Source is a source mapping description for a file |
| type Source struct { |
| Locations map[string]*Locations `protobuf:"bytes,1,rep,name=locations,proto3" json:"locations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` |
| Infos []*SourceInfo `protobuf:"bytes,2,rep,name=infos,proto3" json:"infos,omitempty"` |
| } |
| |
| func (m *Source) Reset() { *m = Source{} } |
| func (m *Source) String() string { return proto.CompactTextString(m) } |
| func (*Source) ProtoMessage() {} |
| func (*Source) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{13} |
| } |
| func (m *Source) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *Source) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *Source) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_Source.Merge(m, src) |
| } |
| func (m *Source) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *Source) XXX_DiscardUnknown() { |
| xxx_messageInfo_Source.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_Source proto.InternalMessageInfo |
| |
| func (m *Source) GetLocations() map[string]*Locations { |
| if m != nil { |
| return m.Locations |
| } |
| return nil |
| } |
| |
| func (m *Source) GetInfos() []*SourceInfo { |
| if m != nil { |
| return m.Infos |
| } |
| return nil |
| } |
| |
| // Locations is a list of ranges with a index to its source map. |
| type Locations struct { |
| Locations []*Location `protobuf:"bytes,1,rep,name=locations,proto3" json:"locations,omitempty"` |
| } |
| |
| func (m *Locations) Reset() { *m = Locations{} } |
| func (m *Locations) String() string { return proto.CompactTextString(m) } |
| func (*Locations) ProtoMessage() {} |
| func (*Locations) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{14} |
| } |
| func (m *Locations) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *Locations) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *Locations) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_Locations.Merge(m, src) |
| } |
| func (m *Locations) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *Locations) XXX_DiscardUnknown() { |
| xxx_messageInfo_Locations.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_Locations proto.InternalMessageInfo |
| |
| func (m *Locations) GetLocations() []*Location { |
| if m != nil { |
| return m.Locations |
| } |
| return nil |
| } |
| |
| // Source info contains the shared metadata of a source mapping |
| type SourceInfo struct { |
| Filename string `protobuf:"bytes,1,opt,name=filename,proto3" json:"filename,omitempty"` |
| Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` |
| Definition *Definition `protobuf:"bytes,3,opt,name=definition,proto3" json:"definition,omitempty"` |
| } |
| |
| func (m *SourceInfo) Reset() { *m = SourceInfo{} } |
| func (m *SourceInfo) String() string { return proto.CompactTextString(m) } |
| func (*SourceInfo) ProtoMessage() {} |
| func (*SourceInfo) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{15} |
| } |
| func (m *SourceInfo) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *SourceInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *SourceInfo) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_SourceInfo.Merge(m, src) |
| } |
| func (m *SourceInfo) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *SourceInfo) XXX_DiscardUnknown() { |
| xxx_messageInfo_SourceInfo.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_SourceInfo proto.InternalMessageInfo |
| |
| func (m *SourceInfo) GetFilename() string { |
| if m != nil { |
| return m.Filename |
| } |
| return "" |
| } |
| |
| func (m *SourceInfo) GetData() []byte { |
| if m != nil { |
| return m.Data |
| } |
| return nil |
| } |
| |
| func (m *SourceInfo) GetDefinition() *Definition { |
| if m != nil { |
| return m.Definition |
| } |
| return nil |
| } |
| |
| // Location defines list of areas in to source file |
| type Location struct { |
| SourceIndex int32 `protobuf:"varint,1,opt,name=sourceIndex,proto3" json:"sourceIndex,omitempty"` |
| Ranges []*Range `protobuf:"bytes,2,rep,name=ranges,proto3" json:"ranges,omitempty"` |
| } |
| |
| func (m *Location) Reset() { *m = Location{} } |
| func (m *Location) String() string { return proto.CompactTextString(m) } |
| func (*Location) ProtoMessage() {} |
| func (*Location) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{16} |
| } |
| func (m *Location) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *Location) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *Location) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_Location.Merge(m, src) |
| } |
| func (m *Location) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *Location) XXX_DiscardUnknown() { |
| xxx_messageInfo_Location.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_Location proto.InternalMessageInfo |
| |
| func (m *Location) GetSourceIndex() int32 { |
| if m != nil { |
| return m.SourceIndex |
| } |
| return 0 |
| } |
| |
| func (m *Location) GetRanges() []*Range { |
| if m != nil { |
| return m.Ranges |
| } |
| return nil |
| } |
| |
| // Range is an area in the source file |
| type Range struct { |
| Start Position `protobuf:"bytes,1,opt,name=start,proto3" json:"start"` |
| End Position `protobuf:"bytes,2,opt,name=end,proto3" json:"end"` |
| } |
| |
| func (m *Range) Reset() { *m = Range{} } |
| func (m *Range) String() string { return proto.CompactTextString(m) } |
| func (*Range) ProtoMessage() {} |
| func (*Range) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{17} |
| } |
| func (m *Range) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *Range) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *Range) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_Range.Merge(m, src) |
| } |
| func (m *Range) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *Range) XXX_DiscardUnknown() { |
| xxx_messageInfo_Range.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_Range proto.InternalMessageInfo |
| |
| func (m *Range) GetStart() Position { |
| if m != nil { |
| return m.Start |
| } |
| return Position{} |
| } |
| |
| func (m *Range) GetEnd() Position { |
| if m != nil { |
| return m.End |
| } |
| return Position{} |
| } |
| |
| // Position is single location in a source file |
| type Position struct { |
| Line int32 `protobuf:"varint,1,opt,name=Line,proto3" json:"Line,omitempty"` |
| Character int32 `protobuf:"varint,2,opt,name=Character,proto3" json:"Character,omitempty"` |
| } |
| |
| func (m *Position) Reset() { *m = Position{} } |
| func (m *Position) String() string { return proto.CompactTextString(m) } |
| func (*Position) ProtoMessage() {} |
| func (*Position) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{18} |
| } |
| func (m *Position) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *Position) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *Position) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_Position.Merge(m, src) |
| } |
| func (m *Position) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *Position) XXX_DiscardUnknown() { |
| xxx_messageInfo_Position.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_Position proto.InternalMessageInfo |
| |
| func (m *Position) GetLine() int32 { |
| if m != nil { |
| return m.Line |
| } |
| return 0 |
| } |
| |
| func (m *Position) GetCharacter() int32 { |
| if m != nil { |
| return m.Character |
| } |
| return 0 |
| } |
| |
| type ExportCache struct { |
| Value bool `protobuf:"varint,1,opt,name=Value,proto3" json:"Value,omitempty"` |
| } |
| |
| func (m *ExportCache) Reset() { *m = ExportCache{} } |
| func (m *ExportCache) String() string { return proto.CompactTextString(m) } |
| func (*ExportCache) ProtoMessage() {} |
| func (*ExportCache) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{19} |
| } |
| func (m *ExportCache) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *ExportCache) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *ExportCache) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_ExportCache.Merge(m, src) |
| } |
| func (m *ExportCache) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *ExportCache) XXX_DiscardUnknown() { |
| xxx_messageInfo_ExportCache.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_ExportCache proto.InternalMessageInfo |
| |
| func (m *ExportCache) GetValue() bool { |
| if m != nil { |
| return m.Value |
| } |
| return false |
| } |
| |
| type ProxyEnv struct { |
| HttpProxy string `protobuf:"bytes,1,opt,name=http_proxy,json=httpProxy,proto3" json:"http_proxy,omitempty"` |
| HttpsProxy string `protobuf:"bytes,2,opt,name=https_proxy,json=httpsProxy,proto3" json:"https_proxy,omitempty"` |
| FtpProxy string `protobuf:"bytes,3,opt,name=ftp_proxy,json=ftpProxy,proto3" json:"ftp_proxy,omitempty"` |
| NoProxy string `protobuf:"bytes,4,opt,name=no_proxy,json=noProxy,proto3" json:"no_proxy,omitempty"` |
| } |
| |
| func (m *ProxyEnv) Reset() { *m = ProxyEnv{} } |
| func (m *ProxyEnv) String() string { return proto.CompactTextString(m) } |
| func (*ProxyEnv) ProtoMessage() {} |
| func (*ProxyEnv) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{20} |
| } |
| func (m *ProxyEnv) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *ProxyEnv) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *ProxyEnv) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_ProxyEnv.Merge(m, src) |
| } |
| func (m *ProxyEnv) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *ProxyEnv) XXX_DiscardUnknown() { |
| xxx_messageInfo_ProxyEnv.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_ProxyEnv proto.InternalMessageInfo |
| |
| func (m *ProxyEnv) GetHttpProxy() string { |
| if m != nil { |
| return m.HttpProxy |
| } |
| return "" |
| } |
| |
| func (m *ProxyEnv) GetHttpsProxy() string { |
| if m != nil { |
| return m.HttpsProxy |
| } |
| return "" |
| } |
| |
| func (m *ProxyEnv) GetFtpProxy() string { |
| if m != nil { |
| return m.FtpProxy |
| } |
| return "" |
| } |
| |
| func (m *ProxyEnv) GetNoProxy() string { |
| if m != nil { |
| return m.NoProxy |
| } |
| return "" |
| } |
| |
| // WorkerConstraints defines conditions for the worker |
| type WorkerConstraints struct { |
| Filter []string `protobuf:"bytes,1,rep,name=filter,proto3" json:"filter,omitempty"` |
| } |
| |
| func (m *WorkerConstraints) Reset() { *m = WorkerConstraints{} } |
| func (m *WorkerConstraints) String() string { return proto.CompactTextString(m) } |
| func (*WorkerConstraints) ProtoMessage() {} |
| func (*WorkerConstraints) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{21} |
| } |
| func (m *WorkerConstraints) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *WorkerConstraints) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *WorkerConstraints) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_WorkerConstraints.Merge(m, src) |
| } |
| func (m *WorkerConstraints) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *WorkerConstraints) XXX_DiscardUnknown() { |
| xxx_messageInfo_WorkerConstraints.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_WorkerConstraints proto.InternalMessageInfo |
| |
| func (m *WorkerConstraints) GetFilter() []string { |
| if m != nil { |
| return m.Filter |
| } |
| return nil |
| } |
| |
| // Definition is the LLB definition structure with per-vertex metadata entries |
| type Definition struct { |
| // def is a list of marshaled Op messages |
| Def [][]byte `protobuf:"bytes,1,rep,name=def,proto3" json:"def,omitempty"` |
| // metadata contains metadata for the each of the Op messages. |
| // A key must be an LLB op digest string. Currently, empty string is not expected as a key, but it may change in the future. |
| Metadata map[github_com_opencontainers_go_digest.Digest]OpMetadata `protobuf:"bytes,2,rep,name=metadata,proto3,castkey=github.com/opencontainers/go-digest.Digest" json:"metadata" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` |
| // Source contains the source mapping information for the vertexes in the definition |
| Source *Source `protobuf:"bytes,3,opt,name=Source,proto3" json:"Source,omitempty"` |
| } |
| |
| func (m *Definition) Reset() { *m = Definition{} } |
| func (m *Definition) String() string { return proto.CompactTextString(m) } |
| func (*Definition) ProtoMessage() {} |
| func (*Definition) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{22} |
| } |
| func (m *Definition) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *Definition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *Definition) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_Definition.Merge(m, src) |
| } |
| func (m *Definition) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *Definition) XXX_DiscardUnknown() { |
| xxx_messageInfo_Definition.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_Definition proto.InternalMessageInfo |
| |
| func (m *Definition) GetDef() [][]byte { |
| if m != nil { |
| return m.Def |
| } |
| return nil |
| } |
| |
| func (m *Definition) GetMetadata() map[github_com_opencontainers_go_digest.Digest]OpMetadata { |
| if m != nil { |
| return m.Metadata |
| } |
| return nil |
| } |
| |
| func (m *Definition) GetSource() *Source { |
| if m != nil { |
| return m.Source |
| } |
| return nil |
| } |
| |
| type HostIP struct { |
| Host string `protobuf:"bytes,1,opt,name=Host,proto3" json:"Host,omitempty"` |
| IP string `protobuf:"bytes,2,opt,name=IP,proto3" json:"IP,omitempty"` |
| } |
| |
| func (m *HostIP) Reset() { *m = HostIP{} } |
| func (m *HostIP) String() string { return proto.CompactTextString(m) } |
| func (*HostIP) ProtoMessage() {} |
| func (*HostIP) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{23} |
| } |
| func (m *HostIP) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *HostIP) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *HostIP) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_HostIP.Merge(m, src) |
| } |
| func (m *HostIP) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *HostIP) XXX_DiscardUnknown() { |
| xxx_messageInfo_HostIP.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_HostIP proto.InternalMessageInfo |
| |
| func (m *HostIP) GetHost() string { |
| if m != nil { |
| return m.Host |
| } |
| return "" |
| } |
| |
| func (m *HostIP) GetIP() string { |
| if m != nil { |
| return m.IP |
| } |
| return "" |
| } |
| |
| type FileOp struct { |
| Actions []*FileAction `protobuf:"bytes,2,rep,name=actions,proto3" json:"actions,omitempty"` |
| } |
| |
| func (m *FileOp) Reset() { *m = FileOp{} } |
| func (m *FileOp) String() string { return proto.CompactTextString(m) } |
| func (*FileOp) ProtoMessage() {} |
| func (*FileOp) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{24} |
| } |
| func (m *FileOp) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *FileOp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *FileOp) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_FileOp.Merge(m, src) |
| } |
| func (m *FileOp) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *FileOp) XXX_DiscardUnknown() { |
| xxx_messageInfo_FileOp.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_FileOp proto.InternalMessageInfo |
| |
| func (m *FileOp) GetActions() []*FileAction { |
| if m != nil { |
| return m.Actions |
| } |
| return nil |
| } |
| |
| type FileAction struct { |
| Input InputIndex `protobuf:"varint,1,opt,name=input,proto3,customtype=InputIndex" json:"input"` |
| SecondaryInput InputIndex `protobuf:"varint,2,opt,name=secondaryInput,proto3,customtype=InputIndex" json:"secondaryInput"` |
| Output OutputIndex `protobuf:"varint,3,opt,name=output,proto3,customtype=OutputIndex" json:"output"` |
| // Types that are valid to be assigned to Action: |
| // *FileAction_Copy |
| // *FileAction_Mkfile |
| // *FileAction_Mkdir |
| // *FileAction_Rm |
| Action isFileAction_Action `protobuf_oneof:"action"` |
| } |
| |
| func (m *FileAction) Reset() { *m = FileAction{} } |
| func (m *FileAction) String() string { return proto.CompactTextString(m) } |
| func (*FileAction) ProtoMessage() {} |
| func (*FileAction) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{25} |
| } |
| func (m *FileAction) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *FileAction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *FileAction) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_FileAction.Merge(m, src) |
| } |
| func (m *FileAction) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *FileAction) XXX_DiscardUnknown() { |
| xxx_messageInfo_FileAction.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_FileAction proto.InternalMessageInfo |
| |
| type isFileAction_Action interface { |
| isFileAction_Action() |
| MarshalTo([]byte) (int, error) |
| Size() int |
| } |
| |
| type FileAction_Copy struct { |
| Copy *FileActionCopy `protobuf:"bytes,4,opt,name=copy,proto3,oneof" json:"copy,omitempty"` |
| } |
| type FileAction_Mkfile struct { |
| Mkfile *FileActionMkFile `protobuf:"bytes,5,opt,name=mkfile,proto3,oneof" json:"mkfile,omitempty"` |
| } |
| type FileAction_Mkdir struct { |
| Mkdir *FileActionMkDir `protobuf:"bytes,6,opt,name=mkdir,proto3,oneof" json:"mkdir,omitempty"` |
| } |
| type FileAction_Rm struct { |
| Rm *FileActionRm `protobuf:"bytes,7,opt,name=rm,proto3,oneof" json:"rm,omitempty"` |
| } |
| |
| func (*FileAction_Copy) isFileAction_Action() {} |
| func (*FileAction_Mkfile) isFileAction_Action() {} |
| func (*FileAction_Mkdir) isFileAction_Action() {} |
| func (*FileAction_Rm) isFileAction_Action() {} |
| |
| func (m *FileAction) GetAction() isFileAction_Action { |
| if m != nil { |
| return m.Action |
| } |
| return nil |
| } |
| |
| func (m *FileAction) GetCopy() *FileActionCopy { |
| if x, ok := m.GetAction().(*FileAction_Copy); ok { |
| return x.Copy |
| } |
| return nil |
| } |
| |
| func (m *FileAction) GetMkfile() *FileActionMkFile { |
| if x, ok := m.GetAction().(*FileAction_Mkfile); ok { |
| return x.Mkfile |
| } |
| return nil |
| } |
| |
| func (m *FileAction) GetMkdir() *FileActionMkDir { |
| if x, ok := m.GetAction().(*FileAction_Mkdir); ok { |
| return x.Mkdir |
| } |
| return nil |
| } |
| |
| func (m *FileAction) GetRm() *FileActionRm { |
| if x, ok := m.GetAction().(*FileAction_Rm); ok { |
| return x.Rm |
| } |
| return nil |
| } |
| |
| // XXX_OneofWrappers is for the internal use of the proto package. |
| func (*FileAction) XXX_OneofWrappers() []interface{} { |
| return []interface{}{ |
| (*FileAction_Copy)(nil), |
| (*FileAction_Mkfile)(nil), |
| (*FileAction_Mkdir)(nil), |
| (*FileAction_Rm)(nil), |
| } |
| } |
| |
| type FileActionCopy struct { |
| // src is the source path |
| Src string `protobuf:"bytes,1,opt,name=src,proto3" json:"src,omitempty"` |
| // dest path |
| Dest string `protobuf:"bytes,2,opt,name=dest,proto3" json:"dest,omitempty"` |
| // optional owner override |
| Owner *ChownOpt `protobuf:"bytes,3,opt,name=owner,proto3" json:"owner,omitempty"` |
| // optional permission bits override |
| Mode int32 `protobuf:"varint,4,opt,name=mode,proto3" json:"mode,omitempty"` |
| // followSymlink resolves symlinks in src |
| FollowSymlink bool `protobuf:"varint,5,opt,name=followSymlink,proto3" json:"followSymlink,omitempty"` |
| // dirCopyContents only copies contents if src is a directory |
| DirCopyContents bool `protobuf:"varint,6,opt,name=dirCopyContents,proto3" json:"dirCopyContents,omitempty"` |
| // attemptUnpackDockerCompatibility detects if src is an archive to unpack it instead |
| AttemptUnpackDockerCompatibility bool `protobuf:"varint,7,opt,name=attemptUnpackDockerCompatibility,proto3" json:"attemptUnpackDockerCompatibility,omitempty"` |
| // createDestPath creates dest path directories if needed |
| CreateDestPath bool `protobuf:"varint,8,opt,name=createDestPath,proto3" json:"createDestPath,omitempty"` |
| // allowWildcard allows filepath.Match wildcards in src path |
| AllowWildcard bool `protobuf:"varint,9,opt,name=allowWildcard,proto3" json:"allowWildcard,omitempty"` |
| // allowEmptyWildcard doesn't fail the whole copy if wildcard doesn't resolve to files |
| AllowEmptyWildcard bool `protobuf:"varint,10,opt,name=allowEmptyWildcard,proto3" json:"allowEmptyWildcard,omitempty"` |
| // optional created time override |
| Timestamp int64 `protobuf:"varint,11,opt,name=timestamp,proto3" json:"timestamp,omitempty"` |
| } |
| |
| func (m *FileActionCopy) Reset() { *m = FileActionCopy{} } |
| func (m *FileActionCopy) String() string { return proto.CompactTextString(m) } |
| func (*FileActionCopy) ProtoMessage() {} |
| func (*FileActionCopy) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{26} |
| } |
| func (m *FileActionCopy) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *FileActionCopy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *FileActionCopy) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_FileActionCopy.Merge(m, src) |
| } |
| func (m *FileActionCopy) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *FileActionCopy) XXX_DiscardUnknown() { |
| xxx_messageInfo_FileActionCopy.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_FileActionCopy proto.InternalMessageInfo |
| |
| func (m *FileActionCopy) GetSrc() string { |
| if m != nil { |
| return m.Src |
| } |
| return "" |
| } |
| |
| func (m *FileActionCopy) GetDest() string { |
| if m != nil { |
| return m.Dest |
| } |
| return "" |
| } |
| |
| func (m *FileActionCopy) GetOwner() *ChownOpt { |
| if m != nil { |
| return m.Owner |
| } |
| return nil |
| } |
| |
| func (m *FileActionCopy) GetMode() int32 { |
| if m != nil { |
| return m.Mode |
| } |
| return 0 |
| } |
| |
| func (m *FileActionCopy) GetFollowSymlink() bool { |
| if m != nil { |
| return m.FollowSymlink |
| } |
| return false |
| } |
| |
| func (m *FileActionCopy) GetDirCopyContents() bool { |
| if m != nil { |
| return m.DirCopyContents |
| } |
| return false |
| } |
| |
| func (m *FileActionCopy) GetAttemptUnpackDockerCompatibility() bool { |
| if m != nil { |
| return m.AttemptUnpackDockerCompatibility |
| } |
| return false |
| } |
| |
| func (m *FileActionCopy) GetCreateDestPath() bool { |
| if m != nil { |
| return m.CreateDestPath |
| } |
| return false |
| } |
| |
| func (m *FileActionCopy) GetAllowWildcard() bool { |
| if m != nil { |
| return m.AllowWildcard |
| } |
| return false |
| } |
| |
| func (m *FileActionCopy) GetAllowEmptyWildcard() bool { |
| if m != nil { |
| return m.AllowEmptyWildcard |
| } |
| return false |
| } |
| |
| func (m *FileActionCopy) GetTimestamp() int64 { |
| if m != nil { |
| return m.Timestamp |
| } |
| return 0 |
| } |
| |
| type FileActionMkFile struct { |
| // path for the new file |
| Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` |
| // permission bits |
| Mode int32 `protobuf:"varint,2,opt,name=mode,proto3" json:"mode,omitempty"` |
| // data is the new file contents |
| Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` |
| // optional owner for the new file |
| Owner *ChownOpt `protobuf:"bytes,4,opt,name=owner,proto3" json:"owner,omitempty"` |
| // optional created time override |
| Timestamp int64 `protobuf:"varint,5,opt,name=timestamp,proto3" json:"timestamp,omitempty"` |
| } |
| |
| func (m *FileActionMkFile) Reset() { *m = FileActionMkFile{} } |
| func (m *FileActionMkFile) String() string { return proto.CompactTextString(m) } |
| func (*FileActionMkFile) ProtoMessage() {} |
| func (*FileActionMkFile) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{27} |
| } |
| func (m *FileActionMkFile) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *FileActionMkFile) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *FileActionMkFile) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_FileActionMkFile.Merge(m, src) |
| } |
| func (m *FileActionMkFile) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *FileActionMkFile) XXX_DiscardUnknown() { |
| xxx_messageInfo_FileActionMkFile.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_FileActionMkFile proto.InternalMessageInfo |
| |
| func (m *FileActionMkFile) GetPath() string { |
| if m != nil { |
| return m.Path |
| } |
| return "" |
| } |
| |
| func (m *FileActionMkFile) GetMode() int32 { |
| if m != nil { |
| return m.Mode |
| } |
| return 0 |
| } |
| |
| func (m *FileActionMkFile) GetData() []byte { |
| if m != nil { |
| return m.Data |
| } |
| return nil |
| } |
| |
| func (m *FileActionMkFile) GetOwner() *ChownOpt { |
| if m != nil { |
| return m.Owner |
| } |
| return nil |
| } |
| |
| func (m *FileActionMkFile) GetTimestamp() int64 { |
| if m != nil { |
| return m.Timestamp |
| } |
| return 0 |
| } |
| |
| type FileActionMkDir struct { |
| // path for the new directory |
| Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` |
| // permission bits |
| Mode int32 `protobuf:"varint,2,opt,name=mode,proto3" json:"mode,omitempty"` |
| // makeParents creates parent directories as well if needed |
| MakeParents bool `protobuf:"varint,3,opt,name=makeParents,proto3" json:"makeParents,omitempty"` |
| // optional owner for the new directory |
| Owner *ChownOpt `protobuf:"bytes,4,opt,name=owner,proto3" json:"owner,omitempty"` |
| // optional created time override |
| Timestamp int64 `protobuf:"varint,5,opt,name=timestamp,proto3" json:"timestamp,omitempty"` |
| } |
| |
| func (m *FileActionMkDir) Reset() { *m = FileActionMkDir{} } |
| func (m *FileActionMkDir) String() string { return proto.CompactTextString(m) } |
| func (*FileActionMkDir) ProtoMessage() {} |
| func (*FileActionMkDir) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{28} |
| } |
| func (m *FileActionMkDir) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *FileActionMkDir) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *FileActionMkDir) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_FileActionMkDir.Merge(m, src) |
| } |
| func (m *FileActionMkDir) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *FileActionMkDir) XXX_DiscardUnknown() { |
| xxx_messageInfo_FileActionMkDir.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_FileActionMkDir proto.InternalMessageInfo |
| |
| func (m *FileActionMkDir) GetPath() string { |
| if m != nil { |
| return m.Path |
| } |
| return "" |
| } |
| |
| func (m *FileActionMkDir) GetMode() int32 { |
| if m != nil { |
| return m.Mode |
| } |
| return 0 |
| } |
| |
| func (m *FileActionMkDir) GetMakeParents() bool { |
| if m != nil { |
| return m.MakeParents |
| } |
| return false |
| } |
| |
| func (m *FileActionMkDir) GetOwner() *ChownOpt { |
| if m != nil { |
| return m.Owner |
| } |
| return nil |
| } |
| |
| func (m *FileActionMkDir) GetTimestamp() int64 { |
| if m != nil { |
| return m.Timestamp |
| } |
| return 0 |
| } |
| |
| type FileActionRm struct { |
| // path to remove |
| Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` |
| // allowNotFound doesn't fail the rm if file is not found |
| AllowNotFound bool `protobuf:"varint,2,opt,name=allowNotFound,proto3" json:"allowNotFound,omitempty"` |
| // allowWildcard allows filepath.Match wildcards in path |
| AllowWildcard bool `protobuf:"varint,3,opt,name=allowWildcard,proto3" json:"allowWildcard,omitempty"` |
| } |
| |
| func (m *FileActionRm) Reset() { *m = FileActionRm{} } |
| func (m *FileActionRm) String() string { return proto.CompactTextString(m) } |
| func (*FileActionRm) ProtoMessage() {} |
| func (*FileActionRm) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{29} |
| } |
| func (m *FileActionRm) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *FileActionRm) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *FileActionRm) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_FileActionRm.Merge(m, src) |
| } |
| func (m *FileActionRm) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *FileActionRm) XXX_DiscardUnknown() { |
| xxx_messageInfo_FileActionRm.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_FileActionRm proto.InternalMessageInfo |
| |
| func (m *FileActionRm) GetPath() string { |
| if m != nil { |
| return m.Path |
| } |
| return "" |
| } |
| |
| func (m *FileActionRm) GetAllowNotFound() bool { |
| if m != nil { |
| return m.AllowNotFound |
| } |
| return false |
| } |
| |
| func (m *FileActionRm) GetAllowWildcard() bool { |
| if m != nil { |
| return m.AllowWildcard |
| } |
| return false |
| } |
| |
| type ChownOpt struct { |
| User *UserOpt `protobuf:"bytes,1,opt,name=user,proto3" json:"user,omitempty"` |
| Group *UserOpt `protobuf:"bytes,2,opt,name=group,proto3" json:"group,omitempty"` |
| } |
| |
| func (m *ChownOpt) Reset() { *m = ChownOpt{} } |
| func (m *ChownOpt) String() string { return proto.CompactTextString(m) } |
| func (*ChownOpt) ProtoMessage() {} |
| func (*ChownOpt) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{30} |
| } |
| func (m *ChownOpt) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *ChownOpt) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *ChownOpt) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_ChownOpt.Merge(m, src) |
| } |
| func (m *ChownOpt) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *ChownOpt) XXX_DiscardUnknown() { |
| xxx_messageInfo_ChownOpt.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_ChownOpt proto.InternalMessageInfo |
| |
| func (m *ChownOpt) GetUser() *UserOpt { |
| if m != nil { |
| return m.User |
| } |
| return nil |
| } |
| |
| func (m *ChownOpt) GetGroup() *UserOpt { |
| if m != nil { |
| return m.Group |
| } |
| return nil |
| } |
| |
| type UserOpt struct { |
| // Types that are valid to be assigned to User: |
| // *UserOpt_ByName |
| // *UserOpt_ByID |
| User isUserOpt_User `protobuf_oneof:"user"` |
| } |
| |
| func (m *UserOpt) Reset() { *m = UserOpt{} } |
| func (m *UserOpt) String() string { return proto.CompactTextString(m) } |
| func (*UserOpt) ProtoMessage() {} |
| func (*UserOpt) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{31} |
| } |
| func (m *UserOpt) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *UserOpt) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *UserOpt) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_UserOpt.Merge(m, src) |
| } |
| func (m *UserOpt) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *UserOpt) XXX_DiscardUnknown() { |
| xxx_messageInfo_UserOpt.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_UserOpt proto.InternalMessageInfo |
| |
| type isUserOpt_User interface { |
| isUserOpt_User() |
| MarshalTo([]byte) (int, error) |
| Size() int |
| } |
| |
| type UserOpt_ByName struct { |
| ByName *NamedUserOpt `protobuf:"bytes,1,opt,name=byName,proto3,oneof" json:"byName,omitempty"` |
| } |
| type UserOpt_ByID struct { |
| ByID uint32 `protobuf:"varint,2,opt,name=byID,proto3,oneof" json:"byID,omitempty"` |
| } |
| |
| func (*UserOpt_ByName) isUserOpt_User() {} |
| func (*UserOpt_ByID) isUserOpt_User() {} |
| |
| func (m *UserOpt) GetUser() isUserOpt_User { |
| if m != nil { |
| return m.User |
| } |
| return nil |
| } |
| |
| func (m *UserOpt) GetByName() *NamedUserOpt { |
| if x, ok := m.GetUser().(*UserOpt_ByName); ok { |
| return x.ByName |
| } |
| return nil |
| } |
| |
| func (m *UserOpt) GetByID() uint32 { |
| if x, ok := m.GetUser().(*UserOpt_ByID); ok { |
| return x.ByID |
| } |
| return 0 |
| } |
| |
| // XXX_OneofWrappers is for the internal use of the proto package. |
| func (*UserOpt) XXX_OneofWrappers() []interface{} { |
| return []interface{}{ |
| (*UserOpt_ByName)(nil), |
| (*UserOpt_ByID)(nil), |
| } |
| } |
| |
| type NamedUserOpt struct { |
| Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` |
| Input InputIndex `protobuf:"varint,2,opt,name=input,proto3,customtype=InputIndex" json:"input"` |
| } |
| |
| func (m *NamedUserOpt) Reset() { *m = NamedUserOpt{} } |
| func (m *NamedUserOpt) String() string { return proto.CompactTextString(m) } |
| func (*NamedUserOpt) ProtoMessage() {} |
| func (*NamedUserOpt) Descriptor() ([]byte, []int) { |
| return fileDescriptor_8de16154b2733812, []int{32} |
| } |
| func (m *NamedUserOpt) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *NamedUserOpt) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *NamedUserOpt) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_NamedUserOpt.Merge(m, src) |
| } |
| func (m *NamedUserOpt) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *NamedUserOpt) XXX_DiscardUnknown() { |
| xxx_messageInfo_NamedUserOpt.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_NamedUserOpt proto.InternalMessageInfo |
| |
| func (m *NamedUserOpt) GetName() string { |
| if m != nil { |
| return m.Name |
| } |
| return "" |
| } |
| |
| func init() { |
| proto.RegisterEnum("pb.NetMode", NetMode_name, NetMode_value) |
| proto.RegisterEnum("pb.SecurityMode", SecurityMode_name, SecurityMode_value) |
| proto.RegisterEnum("pb.MountType", MountType_name, MountType_value) |
| proto.RegisterEnum("pb.CacheSharingOpt", CacheSharingOpt_name, CacheSharingOpt_value) |
| proto.RegisterType((*Op)(nil), "pb.Op") |
| proto.RegisterType((*Platform)(nil), "pb.Platform") |
| proto.RegisterType((*Input)(nil), "pb.Input") |
| proto.RegisterType((*ExecOp)(nil), "pb.ExecOp") |
| proto.RegisterType((*Meta)(nil), "pb.Meta") |
| proto.RegisterType((*Mount)(nil), "pb.Mount") |
| proto.RegisterType((*CacheOpt)(nil), "pb.CacheOpt") |
| proto.RegisterType((*SecretOpt)(nil), "pb.SecretOpt") |
| proto.RegisterType((*SSHOpt)(nil), "pb.SSHOpt") |
| proto.RegisterType((*SourceOp)(nil), "pb.SourceOp") |
| proto.RegisterMapType((map[string]string)(nil), "pb.SourceOp.AttrsEntry") |
| proto.RegisterType((*BuildOp)(nil), "pb.BuildOp") |
| proto.RegisterMapType((map[string]string)(nil), "pb.BuildOp.AttrsEntry") |
| proto.RegisterMapType((map[string]*BuildInput)(nil), "pb.BuildOp.InputsEntry") |
| proto.RegisterType((*BuildInput)(nil), "pb.BuildInput") |
| proto.RegisterType((*OpMetadata)(nil), "pb.OpMetadata") |
| proto.RegisterMapType((map[github_com_moby_buildkit_util_apicaps.CapID]bool)(nil), "pb.OpMetadata.CapsEntry") |
| proto.RegisterMapType((map[string]string)(nil), "pb.OpMetadata.DescriptionEntry") |
| proto.RegisterType((*Source)(nil), "pb.Source") |
| proto.RegisterMapType((map[string]*Locations)(nil), "pb.Source.LocationsEntry") |
| proto.RegisterType((*Locations)(nil), "pb.Locations") |
| proto.RegisterType((*SourceInfo)(nil), "pb.SourceInfo") |
| proto.RegisterType((*Location)(nil), "pb.Location") |
| proto.RegisterType((*Range)(nil), "pb.Range") |
| proto.RegisterType((*Position)(nil), "pb.Position") |
| proto.RegisterType((*ExportCache)(nil), "pb.ExportCache") |
| proto.RegisterType((*ProxyEnv)(nil), "pb.ProxyEnv") |
| proto.RegisterType((*WorkerConstraints)(nil), "pb.WorkerConstraints") |
| proto.RegisterType((*Definition)(nil), "pb.Definition") |
| proto.RegisterMapType((map[github_com_opencontainers_go_digest.Digest]OpMetadata)(nil), "pb.Definition.MetadataEntry") |
| proto.RegisterType((*HostIP)(nil), "pb.HostIP") |
| proto.RegisterType((*FileOp)(nil), "pb.FileOp") |
| proto.RegisterType((*FileAction)(nil), "pb.FileAction") |
| proto.RegisterType((*FileActionCopy)(nil), "pb.FileActionCopy") |
| proto.RegisterType((*FileActionMkFile)(nil), "pb.FileActionMkFile") |
| proto.RegisterType((*FileActionMkDir)(nil), "pb.FileActionMkDir") |
| proto.RegisterType((*FileActionRm)(nil), "pb.FileActionRm") |
| proto.RegisterType((*ChownOpt)(nil), "pb.ChownOpt") |
| proto.RegisterType((*UserOpt)(nil), "pb.UserOpt") |
| proto.RegisterType((*NamedUserOpt)(nil), "pb.NamedUserOpt") |
| } |
| |
| func init() { proto.RegisterFile("ops.proto", fileDescriptor_8de16154b2733812) } |
| |
| var fileDescriptor_8de16154b2733812 = []byte{ |
| // 2217 bytes of a gzipped FileDescriptorProto |
| 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0xcd, 0x6f, 0x1b, 0xc7, |
| 0x15, 0x17, 0xbf, 0xc9, 0x47, 0x49, 0x66, 0x27, 0x4e, 0xc2, 0xa8, 0xae, 0xa4, 0x6c, 0xdc, 0x40, |
| 0x96, 0x6d, 0x0a, 0x50, 0x80, 0x38, 0x08, 0x8a, 0xa2, 0xe2, 0x87, 0x21, 0xc6, 0xb6, 0x28, 0x0c, |
| 0xfd, 0xd1, 0x9b, 0xb1, 0x5a, 0x0e, 0xa9, 0x85, 0xc8, 0x9d, 0xc5, 0xec, 0xd0, 0x16, 0x2f, 0x3d, |
| 0xf8, 0x2f, 0x08, 0x50, 0xa0, 0xb7, 0x16, 0xe8, 0xa5, 0x7f, 0x41, 0xaf, 0x3d, 0x16, 0xc8, 0x31, |
| 0x87, 0x1e, 0x82, 0x1e, 0xd2, 0xc2, 0xbe, 0xf7, 0x3f, 0x28, 0x50, 0xbc, 0x37, 0xb3, 0x1f, 0x94, |
| 0x65, 0xd8, 0x46, 0x8b, 0x9e, 0x76, 0xe6, 0xbd, 0xdf, 0xbc, 0x79, 0xf3, 0xbe, 0xe6, 0xcd, 0x42, |
| 0x4d, 0x86, 0x51, 0x2b, 0x54, 0x52, 0x4b, 0x96, 0x0f, 0x4f, 0x36, 0x6e, 0x4f, 0x7c, 0x7d, 0x3a, |
| 0x3f, 0x69, 0x79, 0x72, 0xb6, 0x37, 0x91, 0x13, 0xb9, 0x47, 0xac, 0x93, 0xf9, 0x98, 0x66, 0x34, |
| 0xa1, 0x91, 0x59, 0xe2, 0xfc, 0x31, 0x0f, 0xf9, 0x41, 0xc8, 0x3e, 0x85, 0xb2, 0x1f, 0x84, 0x73, |
| 0x1d, 0x35, 0x73, 0xdb, 0x85, 0x9d, 0xfa, 0x7e, 0xad, 0x15, 0x9e, 0xb4, 0xfa, 0x48, 0xe1, 0x96, |
| 0xc1, 0xb6, 0xa1, 0x28, 0xce, 0x85, 0xd7, 0xcc, 0x6f, 0xe7, 0x76, 0xea, 0xfb, 0x80, 0x80, 0xde, |
| 0xb9, 0xf0, 0x06, 0xe1, 0xe1, 0x0a, 0x27, 0x0e, 0xfb, 0x1c, 0xca, 0x91, 0x9c, 0x2b, 0x4f, 0x34, |
| 0x0b, 0x84, 0x59, 0x45, 0xcc, 0x90, 0x28, 0x84, 0xb2, 0x5c, 0x94, 0x34, 0xf6, 0xa7, 0xa2, 0x59, |
| 0x4c, 0x25, 0xdd, 0xf5, 0xa7, 0x06, 0x43, 0x1c, 0xf6, 0x19, 0x94, 0x4e, 0xe6, 0xfe, 0x74, 0xd4, |
| 0x2c, 0x11, 0xa4, 0x8e, 0x90, 0x36, 0x12, 0x08, 0x63, 0x78, 0x6c, 0x07, 0xaa, 0xe1, 0xd4, 0xd5, |
| 0x63, 0xa9, 0x66, 0x4d, 0x48, 0x37, 0x3c, 0xb6, 0x34, 0x9e, 0x70, 0xd9, 0x1d, 0xa8, 0x7b, 0x32, |
| 0x88, 0xb4, 0x72, 0xfd, 0x40, 0x47, 0xcd, 0x3a, 0x81, 0x3f, 0x44, 0xf0, 0x13, 0xa9, 0xce, 0x84, |
| 0xea, 0xa4, 0x4c, 0x9e, 0x45, 0xb6, 0x8b, 0x90, 0x97, 0xa1, 0xf3, 0xbb, 0x1c, 0x54, 0x63, 0xa9, |
| 0xcc, 0x81, 0xd5, 0x03, 0xe5, 0x9d, 0xfa, 0x5a, 0x78, 0x7a, 0xae, 0x44, 0x33, 0xb7, 0x9d, 0xdb, |
| 0xa9, 0xf1, 0x25, 0x1a, 0x5b, 0x87, 0xfc, 0x60, 0x48, 0x86, 0xaa, 0xf1, 0xfc, 0x60, 0xc8, 0x9a, |
| 0x50, 0x79, 0xec, 0x2a, 0xdf, 0x0d, 0x34, 0x59, 0xa6, 0xc6, 0xe3, 0x29, 0xbb, 0x06, 0xb5, 0xc1, |
| 0xf0, 0xb1, 0x50, 0x91, 0x2f, 0x03, 0xb2, 0x47, 0x8d, 0xa7, 0x04, 0xb6, 0x09, 0x30, 0x18, 0xde, |
| 0x15, 0x2e, 0x0a, 0x8d, 0x9a, 0xa5, 0xed, 0xc2, 0x4e, 0x8d, 0x67, 0x28, 0xce, 0x6f, 0xa0, 0x44, |
| 0x3e, 0x62, 0xdf, 0x40, 0x79, 0xe4, 0x4f, 0x44, 0xa4, 0x8d, 0x3a, 0xed, 0xfd, 0xef, 0x7e, 0xdc, |
| 0x5a, 0xf9, 0xfb, 0x8f, 0x5b, 0xbb, 0x99, 0x60, 0x90, 0xa1, 0x08, 0x3c, 0x19, 0x68, 0xd7, 0x0f, |
| 0x84, 0x8a, 0xf6, 0x26, 0xf2, 0xb6, 0x59, 0xd2, 0xea, 0xd2, 0x87, 0x5b, 0x09, 0xec, 0x06, 0x94, |
| 0xfc, 0x60, 0x24, 0xce, 0x49, 0xff, 0x42, 0xfb, 0x03, 0x2b, 0xaa, 0x3e, 0x98, 0xeb, 0x70, 0xae, |
| 0xfb, 0xc8, 0xe2, 0x06, 0xe1, 0xfc, 0x21, 0x07, 0x65, 0x13, 0x03, 0xec, 0x1a, 0x14, 0x67, 0x42, |
| 0xbb, 0xb4, 0x7f, 0x7d, 0xbf, 0x8a, 0xb6, 0x7d, 0x20, 0xb4, 0xcb, 0x89, 0x8a, 0xe1, 0x35, 0x93, |
| 0x73, 0xb4, 0x7d, 0x3e, 0x0d, 0xaf, 0x07, 0x48, 0xe1, 0x96, 0xc1, 0x7e, 0x0e, 0x95, 0x40, 0xe8, |
| 0xe7, 0x52, 0x9d, 0x91, 0x8d, 0xd6, 0x8d, 0xd3, 0x8f, 0x84, 0x7e, 0x20, 0x47, 0x82, 0xc7, 0x3c, |
| 0x76, 0x0b, 0xaa, 0x91, 0xf0, 0xe6, 0xca, 0xd7, 0x0b, 0xb2, 0xd7, 0xfa, 0x7e, 0x83, 0xa2, 0xcc, |
| 0xd2, 0x08, 0x9c, 0x20, 0x9c, 0xbf, 0xe6, 0xa0, 0x88, 0x6a, 0x30, 0x06, 0x45, 0x57, 0x4d, 0x4c, |
| 0x74, 0xd7, 0x38, 0x8d, 0x59, 0x03, 0x0a, 0x22, 0x78, 0x46, 0x1a, 0xd5, 0x38, 0x0e, 0x91, 0xe2, |
| 0x3d, 0x1f, 0x59, 0x1f, 0xe1, 0x10, 0xd7, 0xcd, 0x23, 0xa1, 0xac, 0x6b, 0x68, 0xcc, 0x6e, 0x40, |
| 0x2d, 0x54, 0xf2, 0x7c, 0xf1, 0x14, 0x57, 0x97, 0x32, 0x81, 0x87, 0xc4, 0x5e, 0xf0, 0x8c, 0x57, |
| 0x43, 0x3b, 0x62, 0xbb, 0x00, 0xe2, 0x5c, 0x2b, 0xf7, 0x50, 0x46, 0x3a, 0x6a, 0x96, 0xe9, 0xec, |
| 0x14, 0xef, 0x48, 0xe8, 0x1f, 0xf3, 0x0c, 0x97, 0x6d, 0x40, 0xf5, 0x54, 0x46, 0x3a, 0x70, 0x67, |
| 0xa2, 0x59, 0xa1, 0xed, 0x92, 0xb9, 0xf3, 0xaf, 0x3c, 0x94, 0xc8, 0x5c, 0x6c, 0x07, 0xbd, 0x13, |
| 0xce, 0x8d, 0xa3, 0x0b, 0x6d, 0x66, 0xbd, 0x03, 0x14, 0x07, 0x89, 0x73, 0x30, 0x26, 0x36, 0xd0, |
| 0x52, 0x53, 0xe1, 0x69, 0xa9, 0x6c, 0x28, 0x26, 0x73, 0x3c, 0xd6, 0x08, 0xa3, 0xc5, 0x9c, 0x94, |
| 0xc6, 0xec, 0x26, 0x94, 0x25, 0xb9, 0x98, 0x0e, 0xfb, 0x06, 0xc7, 0x5b, 0x08, 0x0a, 0x57, 0xc2, |
| 0x1d, 0xc9, 0x60, 0xba, 0x20, 0x13, 0x54, 0x79, 0x32, 0x67, 0x37, 0xa1, 0x46, 0x3e, 0x7d, 0xb8, |
| 0x08, 0x45, 0xb3, 0x4c, 0x3e, 0x5a, 0x4b, 0xfc, 0x8d, 0x44, 0x9e, 0xf2, 0x31, 0x89, 0x3d, 0xd7, |
| 0x3b, 0x15, 0x83, 0x50, 0x37, 0xaf, 0xa6, 0xb6, 0xec, 0x58, 0x1a, 0x4f, 0xb8, 0x28, 0x36, 0x12, |
| 0x9e, 0x12, 0x1a, 0xa1, 0x1f, 0x12, 0x74, 0xcd, 0xba, 0xde, 0x10, 0x79, 0xca, 0x67, 0x0e, 0x94, |
| 0x87, 0xc3, 0x43, 0x44, 0x7e, 0x94, 0x16, 0x19, 0x43, 0xe1, 0x96, 0x63, 0xce, 0x10, 0xcd, 0xa7, |
| 0xba, 0xdf, 0x6d, 0x7e, 0x6c, 0x0c, 0x14, 0xcf, 0x9d, 0x3e, 0x54, 0x63, 0x15, 0x30, 0x9b, 0xfb, |
| 0x5d, 0x9b, 0xe7, 0xf9, 0x7e, 0x97, 0xdd, 0x86, 0x4a, 0x74, 0xea, 0x2a, 0x3f, 0x98, 0x90, 0x5d, |
| 0xd7, 0xf7, 0x3f, 0x48, 0x34, 0x1e, 0x1a, 0x3a, 0xee, 0x12, 0x63, 0x1c, 0x09, 0xb5, 0x44, 0xc5, |
| 0xd7, 0x64, 0x35, 0xa0, 0x30, 0xf7, 0x47, 0x24, 0x67, 0x8d, 0xe3, 0x10, 0x29, 0x13, 0xdf, 0xc4, |
| 0xe0, 0x1a, 0xc7, 0x21, 0x3a, 0x6b, 0x26, 0x47, 0xa6, 0x5c, 0xae, 0x71, 0x1a, 0xa3, 0xee, 0x32, |
| 0xd4, 0xbe, 0x0c, 0xdc, 0x69, 0x6c, 0xff, 0x78, 0xee, 0x4c, 0xe3, 0xb3, 0xff, 0x5f, 0x76, 0xfb, |
| 0x6d, 0x0e, 0xaa, 0x71, 0x8d, 0xc7, 0x82, 0xe5, 0x8f, 0x44, 0xa0, 0xfd, 0xb1, 0x2f, 0x94, 0xdd, |
| 0x38, 0x43, 0x61, 0xb7, 0xa1, 0xe4, 0x6a, 0xad, 0xe2, 0x32, 0xf0, 0x71, 0xf6, 0x82, 0x68, 0x1d, |
| 0x20, 0xa7, 0x17, 0x68, 0xb5, 0xe0, 0x06, 0xb5, 0xf1, 0x15, 0x40, 0x4a, 0x44, 0x5d, 0xcf, 0xc4, |
| 0xc2, 0x4a, 0xc5, 0x21, 0xbb, 0x0a, 0xa5, 0x67, 0xee, 0x74, 0x2e, 0x6c, 0x7c, 0x9b, 0xc9, 0xd7, |
| 0xf9, 0xaf, 0x72, 0xce, 0x5f, 0xf2, 0x50, 0xb1, 0x17, 0x06, 0xbb, 0x05, 0x15, 0xba, 0x30, 0xac, |
| 0x46, 0x97, 0x27, 0x4d, 0x0c, 0x61, 0x7b, 0xc9, 0x4d, 0x98, 0xd1, 0xd1, 0x8a, 0x32, 0x37, 0xa2, |
| 0xd5, 0x31, 0xbd, 0x17, 0x0b, 0x23, 0x31, 0xb6, 0x57, 0xde, 0x3a, 0xa2, 0xbb, 0x62, 0xec, 0x07, |
| 0x3e, 0xda, 0x87, 0x23, 0x8b, 0xdd, 0x8a, 0x4f, 0x5d, 0x24, 0x89, 0x1f, 0x65, 0x25, 0xbe, 0x7e, |
| 0xe8, 0x3e, 0xd4, 0x33, 0xdb, 0x5c, 0x72, 0xea, 0xeb, 0xd9, 0x53, 0xdb, 0x2d, 0x49, 0x9c, 0xb9, |
| 0xaf, 0x53, 0x2b, 0xfc, 0x17, 0xf6, 0xfb, 0x12, 0x20, 0x15, 0xf9, 0xee, 0x45, 0xc7, 0x79, 0x51, |
| 0x00, 0x18, 0x84, 0x58, 0x72, 0x47, 0x2e, 0xd5, 0xfd, 0x55, 0x7f, 0x12, 0x48, 0x25, 0x9e, 0x52, |
| 0x1a, 0xd3, 0xfa, 0x2a, 0xaf, 0x1b, 0x1a, 0x65, 0x0c, 0x3b, 0x80, 0xfa, 0x48, 0x44, 0x9e, 0xf2, |
| 0x29, 0xa0, 0xac, 0xd1, 0xb7, 0xf0, 0x4c, 0xa9, 0x9c, 0x56, 0x37, 0x45, 0x18, 0x5b, 0x65, 0xd7, |
| 0xb0, 0x7d, 0x58, 0x15, 0xe7, 0xa1, 0x54, 0xda, 0xee, 0x62, 0xfa, 0x8a, 0x2b, 0xa6, 0x43, 0x41, |
| 0x3a, 0xed, 0xc4, 0xeb, 0x22, 0x9d, 0x30, 0x17, 0x8a, 0x9e, 0x1b, 0x9a, 0x4b, 0xb5, 0xbe, 0xdf, |
| 0xbc, 0xb0, 0x5f, 0xc7, 0x0d, 0x8d, 0xd1, 0xda, 0x5f, 0xe0, 0x59, 0x5f, 0xfc, 0x63, 0xeb, 0x66, |
| 0xe6, 0x26, 0x9d, 0xc9, 0x93, 0xc5, 0x1e, 0xc5, 0xcb, 0x99, 0xaf, 0xf7, 0xe6, 0xda, 0x9f, 0xee, |
| 0xb9, 0xa1, 0x8f, 0xe2, 0x70, 0x61, 0xbf, 0xcb, 0x49, 0xf4, 0xc6, 0x2f, 0xa1, 0x71, 0x51, 0xef, |
| 0xf7, 0xf1, 0xc1, 0xc6, 0x1d, 0xa8, 0x25, 0x7a, 0xbc, 0x6d, 0x61, 0x35, 0xeb, 0xbc, 0x3f, 0xe7, |
| 0xa0, 0x6c, 0xb2, 0x8a, 0xdd, 0x81, 0xda, 0x54, 0x7a, 0x2e, 0x2a, 0x10, 0xb7, 0x76, 0x9f, 0xa4, |
| 0x49, 0xd7, 0xba, 0x1f, 0xf3, 0x8c, 0x55, 0x53, 0x2c, 0x06, 0x99, 0x1f, 0x8c, 0x65, 0x9c, 0x05, |
| 0xeb, 0xe9, 0xa2, 0x7e, 0x30, 0x96, 0xdc, 0x30, 0x37, 0xee, 0xc1, 0xfa, 0xb2, 0x88, 0x4b, 0xf4, |
| 0xfc, 0x6c, 0x39, 0x5c, 0xa9, 0x66, 0x27, 0x8b, 0xb2, 0x6a, 0xdf, 0x81, 0x5a, 0x42, 0x67, 0xbb, |
| 0xaf, 0x2b, 0xbe, 0x9a, 0x5d, 0x99, 0xd1, 0xd5, 0x99, 0x02, 0xa4, 0xaa, 0x61, 0xb1, 0xc2, 0x1e, |
| 0x92, 0xee, 0x51, 0xa3, 0x46, 0x32, 0xa7, 0x7b, 0xcf, 0xd5, 0x2e, 0xa9, 0xb2, 0xca, 0x69, 0xcc, |
| 0x5a, 0x00, 0xa3, 0x24, 0x61, 0xdf, 0x90, 0xc6, 0x19, 0x84, 0x33, 0x80, 0x6a, 0xac, 0x04, 0xdb, |
| 0x86, 0x7a, 0x64, 0x77, 0xc6, 0x8e, 0x09, 0xb7, 0x2b, 0xf1, 0x2c, 0x09, 0x3b, 0x1f, 0xe5, 0x06, |
| 0x13, 0xb1, 0xd4, 0xf9, 0x70, 0xa4, 0x70, 0xcb, 0x70, 0x9e, 0x40, 0x89, 0x08, 0x98, 0x66, 0x91, |
| 0x76, 0x95, 0xb6, 0x4d, 0x94, 0x69, 0x2a, 0x64, 0x44, 0xdb, 0xb6, 0x8b, 0x18, 0x88, 0xdc, 0x00, |
| 0xd8, 0x75, 0x6c, 0x5d, 0x46, 0xd6, 0xa2, 0x97, 0xe1, 0x90, 0xed, 0xfc, 0x02, 0xaa, 0x31, 0x19, |
| 0x4f, 0x7e, 0xdf, 0x0f, 0x84, 0x55, 0x91, 0xc6, 0xd8, 0x7c, 0x76, 0x4e, 0x5d, 0xe5, 0x7a, 0x5a, |
| 0x98, 0x16, 0xa1, 0xc4, 0x53, 0x82, 0xf3, 0x19, 0xd4, 0x33, 0xd9, 0x83, 0xe1, 0xf6, 0x98, 0xdc, |
| 0x68, 0x72, 0xd8, 0x4c, 0x9c, 0x17, 0xd8, 0x1a, 0xc7, 0xdd, 0xce, 0xcf, 0x00, 0x4e, 0xb5, 0x0e, |
| 0x9f, 0x52, 0xfb, 0x63, 0x6d, 0x5f, 0x43, 0x0a, 0x21, 0xd8, 0x16, 0xd4, 0x71, 0x12, 0x59, 0xbe, |
| 0x89, 0x77, 0x5a, 0x11, 0x19, 0xc0, 0x4f, 0xa1, 0x36, 0x4e, 0x96, 0x17, 0xac, 0xeb, 0xe2, 0xd5, |
| 0x9f, 0x40, 0x35, 0x90, 0x96, 0x67, 0xba, 0xb1, 0x4a, 0x20, 0x89, 0xe5, 0xdc, 0x84, 0x9f, 0xbc, |
| 0xd6, 0xc7, 0xb3, 0x8f, 0xa0, 0x3c, 0xf6, 0xa7, 0x9a, 0x8a, 0x3e, 0x36, 0x78, 0x76, 0xe6, 0xfc, |
| 0x3b, 0x07, 0x90, 0x7a, 0x16, 0xe3, 0x15, 0xab, 0x37, 0x62, 0x56, 0x4d, 0xb5, 0x9e, 0x42, 0x75, |
| 0x66, 0xeb, 0x80, 0xf5, 0xd9, 0xb5, 0xe5, 0x68, 0x68, 0xc5, 0x65, 0xc2, 0x54, 0x88, 0x7d, 0x5b, |
| 0x21, 0xde, 0xa7, 0xd7, 0x4e, 0x76, 0xa0, 0x46, 0x25, 0xfb, 0x66, 0x82, 0x34, 0xd1, 0xb8, 0xe5, |
| 0x6c, 0xdc, 0x83, 0xb5, 0xa5, 0x2d, 0xdf, 0xf1, 0x4e, 0x48, 0xeb, 0x59, 0x36, 0xcb, 0x6e, 0x41, |
| 0xd9, 0x34, 0x9f, 0x18, 0x12, 0x38, 0xb2, 0x62, 0x68, 0x4c, 0x1d, 0xc3, 0x71, 0xfc, 0x72, 0xe9, |
| 0x1f, 0x3b, 0xfb, 0x50, 0x36, 0x4f, 0x33, 0xb6, 0x03, 0x15, 0xd7, 0x33, 0xe9, 0x98, 0x29, 0x09, |
| 0xc8, 0x3c, 0x20, 0x32, 0x8f, 0xd9, 0xce, 0xdf, 0xf2, 0x00, 0x29, 0xfd, 0x3d, 0x3a, 0xd6, 0xaf, |
| 0x61, 0x3d, 0x12, 0x9e, 0x0c, 0x46, 0xae, 0x5a, 0x10, 0xd7, 0x3e, 0x41, 0x2e, 0x5b, 0x72, 0x01, |
| 0x99, 0xe9, 0x5e, 0x0b, 0x6f, 0xef, 0x5e, 0x77, 0xa0, 0xe8, 0xc9, 0x70, 0x61, 0x2f, 0x0a, 0xb6, |
| 0x7c, 0x90, 0x8e, 0x0c, 0x17, 0xf8, 0x10, 0x45, 0x04, 0x6b, 0x41, 0x79, 0x76, 0x46, 0x8f, 0x55, |
| 0xd3, 0xe8, 0x5f, 0x5d, 0xc6, 0x3e, 0x38, 0xc3, 0x31, 0x3e, 0x6d, 0x0d, 0x8a, 0xdd, 0x84, 0xd2, |
| 0xec, 0x6c, 0xe4, 0x2b, 0xea, 0x7b, 0xeb, 0xa6, 0x33, 0xcc, 0xc2, 0xbb, 0xbe, 0xc2, 0x07, 0x2c, |
| 0x61, 0x98, 0x03, 0x79, 0x35, 0xa3, 0x5e, 0xbf, 0x6e, 0x5e, 0x31, 0x19, 0x6b, 0xce, 0x0e, 0x57, |
| 0x78, 0x5e, 0xcd, 0xda, 0x55, 0x28, 0x1b, 0xbb, 0x3a, 0x7f, 0x2a, 0xc0, 0xfa, 0xb2, 0x96, 0x18, |
| 0x07, 0x91, 0xf2, 0xe2, 0x38, 0x88, 0x94, 0x97, 0x34, 0xf6, 0xf9, 0x4c, 0x63, 0xef, 0x40, 0x49, |
| 0x3e, 0x0f, 0x84, 0xca, 0xbe, 0xca, 0x3b, 0xa7, 0xf2, 0x79, 0x80, 0x6d, 0xaa, 0x61, 0x2d, 0x75, |
| 0x7d, 0x25, 0xdb, 0xf5, 0x5d, 0x87, 0xb5, 0xb1, 0x9c, 0x4e, 0xe5, 0xf3, 0xe1, 0x62, 0x36, 0xf5, |
| 0x83, 0x33, 0xdb, 0xfa, 0x2d, 0x13, 0xd9, 0x0e, 0x5c, 0x19, 0xf9, 0x0a, 0xd5, 0xe9, 0xc8, 0x40, |
| 0x8b, 0x80, 0xde, 0x39, 0x88, 0xbb, 0x48, 0x66, 0xdf, 0xc0, 0xb6, 0xab, 0xb5, 0x98, 0x85, 0xfa, |
| 0x51, 0x10, 0xba, 0xde, 0x59, 0x57, 0x7a, 0x94, 0xb3, 0xb3, 0xd0, 0xd5, 0xfe, 0x89, 0x3f, 0xc5, |
| 0x27, 0x5d, 0x85, 0x96, 0xbe, 0x15, 0xc7, 0x3e, 0x87, 0x75, 0x4f, 0x09, 0x57, 0x8b, 0xae, 0x88, |
| 0xf4, 0xb1, 0xab, 0x4f, 0x9b, 0x55, 0x5a, 0x79, 0x81, 0x8a, 0x67, 0x70, 0x51, 0xdb, 0x27, 0xfe, |
| 0x74, 0xe4, 0xb9, 0x6a, 0xd4, 0xac, 0x99, 0x33, 0x2c, 0x11, 0x59, 0x0b, 0x18, 0x11, 0x7a, 0xb3, |
| 0x50, 0x2f, 0x12, 0x28, 0x10, 0xf4, 0x12, 0x0e, 0x16, 0x4e, 0xed, 0xcf, 0x44, 0xa4, 0xdd, 0x59, |
| 0x48, 0x7f, 0x13, 0x0a, 0x3c, 0x25, 0x38, 0xdf, 0xe6, 0xa0, 0x71, 0x31, 0x44, 0xd0, 0xc0, 0x21, |
| 0xaa, 0x69, 0x93, 0x0d, 0xc7, 0x89, 0xd1, 0xf3, 0x19, 0xa3, 0xc7, 0x37, 0x54, 0x21, 0x73, 0x43, |
| 0x25, 0x0e, 0x2c, 0xbe, 0xd9, 0x81, 0x4b, 0x2a, 0x95, 0x2e, 0xaa, 0xf4, 0xfb, 0x1c, 0x5c, 0xb9, |
| 0x10, 0x86, 0xef, 0xac, 0xd1, 0x36, 0xd4, 0x67, 0xee, 0x99, 0x38, 0x76, 0x15, 0x39, 0xb7, 0x60, |
| 0x5a, 0xb8, 0x0c, 0xe9, 0x7f, 0xa0, 0x5f, 0x00, 0xab, 0xd9, 0xd8, 0xbf, 0x54, 0xb7, 0xd8, 0x95, |
| 0x47, 0x52, 0xdf, 0x95, 0x73, 0x7b, 0xfb, 0xc5, 0xae, 0x8c, 0x89, 0xaf, 0x3b, 0xbc, 0x70, 0x89, |
| 0xc3, 0x9d, 0x23, 0xa8, 0xc6, 0x0a, 0xb2, 0x2d, 0xfb, 0xc4, 0xcf, 0xa5, 0xbf, 0x9a, 0x1e, 0x45, |
| 0x42, 0xa1, 0xee, 0xe6, 0xbd, 0xff, 0x29, 0x94, 0x26, 0x4a, 0xce, 0x43, 0x5b, 0x5b, 0x97, 0x10, |
| 0x86, 0xe3, 0x0c, 0xa1, 0x62, 0x29, 0x6c, 0x17, 0xca, 0x27, 0x8b, 0xa3, 0xb8, 0xf9, 0xb0, 0x89, |
| 0x8d, 0xf3, 0x91, 0x45, 0x60, 0xb5, 0x30, 0x08, 0x76, 0x15, 0x8a, 0x27, 0x8b, 0x7e, 0xd7, 0x3c, |
| 0xc8, 0xb0, 0xe6, 0xe0, 0xac, 0x5d, 0x36, 0x0a, 0x39, 0xf7, 0x61, 0x35, 0xbb, 0x0e, 0x8d, 0x92, |
| 0x69, 0x6a, 0x68, 0x9c, 0x16, 0xd7, 0xfc, 0x5b, 0x8a, 0xeb, 0xee, 0x0e, 0x54, 0xec, 0xcf, 0x14, |
| 0x56, 0x83, 0xd2, 0xa3, 0xa3, 0x61, 0xef, 0x61, 0x63, 0x85, 0x55, 0xa1, 0x78, 0x38, 0x18, 0x3e, |
| 0x6c, 0xe4, 0x70, 0x74, 0x34, 0x38, 0xea, 0x35, 0xf2, 0xbb, 0x37, 0x60, 0x35, 0xfb, 0x3b, 0x85, |
| 0xd5, 0xa1, 0x32, 0x3c, 0x38, 0xea, 0xb6, 0x07, 0xbf, 0x6e, 0xac, 0xb0, 0x55, 0xa8, 0xf6, 0x8f, |
| 0x86, 0xbd, 0xce, 0x23, 0xde, 0x6b, 0xe4, 0x76, 0x7f, 0x05, 0xb5, 0xe4, 0x55, 0x8f, 0x12, 0xda, |
| 0xfd, 0xa3, 0x6e, 0x63, 0x85, 0x01, 0x94, 0x87, 0xbd, 0x0e, 0xef, 0xa1, 0xdc, 0x0a, 0x14, 0x86, |
| 0xc3, 0xc3, 0x46, 0x1e, 0x77, 0xed, 0x1c, 0x74, 0x0e, 0x7b, 0x8d, 0x02, 0x0e, 0x1f, 0x3e, 0x38, |
| 0xbe, 0x3b, 0x6c, 0x14, 0x77, 0xbf, 0x84, 0x2b, 0x17, 0x5e, 0xce, 0xb4, 0xfa, 0xf0, 0x80, 0xf7, |
| 0x50, 0x52, 0x1d, 0x2a, 0xc7, 0xbc, 0xff, 0xf8, 0xe0, 0x61, 0xaf, 0x91, 0x43, 0xc6, 0xfd, 0x41, |
| 0xe7, 0x5e, 0xaf, 0xdb, 0xc8, 0xb7, 0xaf, 0x7d, 0xf7, 0x72, 0x33, 0xf7, 0xfd, 0xcb, 0xcd, 0xdc, |
| 0x0f, 0x2f, 0x37, 0x73, 0xff, 0x7c, 0xb9, 0x99, 0xfb, 0xf6, 0xd5, 0xe6, 0xca, 0xf7, 0xaf, 0x36, |
| 0x57, 0x7e, 0x78, 0xb5, 0xb9, 0x72, 0x52, 0xa6, 0x9f, 0x9b, 0x5f, 0xfc, 0x27, 0x00, 0x00, 0xff, |
| 0xff, 0xa4, 0x50, 0x4f, 0x17, 0x1c, 0x15, 0x00, 0x00, |
| } |
| |
| func (m *Op) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *Op) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *Op) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.Constraints != nil { |
| { |
| size, err := m.Constraints.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x5a |
| } |
| if m.Platform != nil { |
| { |
| size, err := m.Platform.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x52 |
| } |
| if m.Op != nil { |
| { |
| size := m.Op.Size() |
| i -= size |
| if _, err := m.Op.MarshalTo(dAtA[i:]); err != nil { |
| return 0, err |
| } |
| } |
| } |
| if len(m.Inputs) > 0 { |
| for iNdEx := len(m.Inputs) - 1; iNdEx >= 0; iNdEx-- { |
| { |
| size, err := m.Inputs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0xa |
| } |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *Op_Exec) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *Op_Exec) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| if m.Exec != nil { |
| { |
| size, err := m.Exec.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| } |
| return len(dAtA) - i, nil |
| } |
| func (m *Op_Source) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *Op_Source) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| if m.Source != nil { |
| { |
| size, err := m.Source.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x1a |
| } |
| return len(dAtA) - i, nil |
| } |
| func (m *Op_File) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *Op_File) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| if m.File != nil { |
| { |
| size, err := m.File.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x22 |
| } |
| return len(dAtA) - i, nil |
| } |
| func (m *Op_Build) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *Op_Build) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| if m.Build != nil { |
| { |
| size, err := m.Build.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x2a |
| } |
| return len(dAtA) - i, nil |
| } |
| func (m *Platform) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *Platform) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *Platform) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if len(m.OSFeatures) > 0 { |
| for iNdEx := len(m.OSFeatures) - 1; iNdEx >= 0; iNdEx-- { |
| i -= len(m.OSFeatures[iNdEx]) |
| copy(dAtA[i:], m.OSFeatures[iNdEx]) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.OSFeatures[iNdEx]))) |
| i-- |
| dAtA[i] = 0x2a |
| } |
| } |
| if len(m.OSVersion) > 0 { |
| i -= len(m.OSVersion) |
| copy(dAtA[i:], m.OSVersion) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.OSVersion))) |
| i-- |
| dAtA[i] = 0x22 |
| } |
| if len(m.Variant) > 0 { |
| i -= len(m.Variant) |
| copy(dAtA[i:], m.Variant) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.Variant))) |
| i-- |
| dAtA[i] = 0x1a |
| } |
| if len(m.OS) > 0 { |
| i -= len(m.OS) |
| copy(dAtA[i:], m.OS) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.OS))) |
| i-- |
| dAtA[i] = 0x12 |
| } |
| if len(m.Architecture) > 0 { |
| i -= len(m.Architecture) |
| copy(dAtA[i:], m.Architecture) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.Architecture))) |
| i-- |
| dAtA[i] = 0xa |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *Input) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *Input) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *Input) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.Index != 0 { |
| i = encodeVarintOps(dAtA, i, uint64(m.Index)) |
| i-- |
| dAtA[i] = 0x10 |
| } |
| if len(m.Digest) > 0 { |
| i -= len(m.Digest) |
| copy(dAtA[i:], m.Digest) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.Digest))) |
| i-- |
| dAtA[i] = 0xa |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *ExecOp) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *ExecOp) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *ExecOp) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.Security != 0 { |
| i = encodeVarintOps(dAtA, i, uint64(m.Security)) |
| i-- |
| dAtA[i] = 0x20 |
| } |
| if m.Network != 0 { |
| i = encodeVarintOps(dAtA, i, uint64(m.Network)) |
| i-- |
| dAtA[i] = 0x18 |
| } |
| if len(m.Mounts) > 0 { |
| for iNdEx := len(m.Mounts) - 1; iNdEx >= 0; iNdEx-- { |
| { |
| size, err := m.Mounts[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| } |
| } |
| if m.Meta != nil { |
| { |
| size, err := m.Meta.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0xa |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *Meta) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *Meta) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *Meta) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if len(m.Hostname) > 0 { |
| i -= len(m.Hostname) |
| copy(dAtA[i:], m.Hostname) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.Hostname))) |
| i-- |
| dAtA[i] = 0x3a |
| } |
| if len(m.ExtraHosts) > 0 { |
| for iNdEx := len(m.ExtraHosts) - 1; iNdEx >= 0; iNdEx-- { |
| { |
| size, err := m.ExtraHosts[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x32 |
| } |
| } |
| if m.ProxyEnv != nil { |
| { |
| size, err := m.ProxyEnv.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x2a |
| } |
| if len(m.User) > 0 { |
| i -= len(m.User) |
| copy(dAtA[i:], m.User) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.User))) |
| i-- |
| dAtA[i] = 0x22 |
| } |
| if len(m.Cwd) > 0 { |
| i -= len(m.Cwd) |
| copy(dAtA[i:], m.Cwd) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.Cwd))) |
| i-- |
| dAtA[i] = 0x1a |
| } |
| if len(m.Env) > 0 { |
| for iNdEx := len(m.Env) - 1; iNdEx >= 0; iNdEx-- { |
| i -= len(m.Env[iNdEx]) |
| copy(dAtA[i:], m.Env[iNdEx]) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.Env[iNdEx]))) |
| i-- |
| dAtA[i] = 0x12 |
| } |
| } |
| if len(m.Args) > 0 { |
| for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- { |
| i -= len(m.Args[iNdEx]) |
| copy(dAtA[i:], m.Args[iNdEx]) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.Args[iNdEx]))) |
| i-- |
| dAtA[i] = 0xa |
| } |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *Mount) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *Mount) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *Mount) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if len(m.ResultID) > 0 { |
| i -= len(m.ResultID) |
| copy(dAtA[i:], m.ResultID) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.ResultID))) |
| i-- |
| dAtA[i] = 0x1 |
| i-- |
| dAtA[i] = 0xba |
| } |
| if m.SSHOpt != nil { |
| { |
| size, err := m.SSHOpt.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x1 |
| i-- |
| dAtA[i] = 0xb2 |
| } |
| if m.SecretOpt != nil { |
| { |
| size, err := m.SecretOpt.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x1 |
| i-- |
| dAtA[i] = 0xaa |
| } |
| if m.CacheOpt != nil { |
| { |
| size, err := m.CacheOpt.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x1 |
| i-- |
| dAtA[i] = 0xa2 |
| } |
| if m.MountType != 0 { |
| i = encodeVarintOps(dAtA, i, uint64(m.MountType)) |
| i-- |
| dAtA[i] = 0x30 |
| } |
| if m.Readonly { |
| i-- |
| if m.Readonly { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i-- |
| dAtA[i] = 0x28 |
| } |
| if m.Output != 0 { |
| i = encodeVarintOps(dAtA, i, uint64(m.Output)) |
| i-- |
| dAtA[i] = 0x20 |
| } |
| if len(m.Dest) > 0 { |
| i -= len(m.Dest) |
| copy(dAtA[i:], m.Dest) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.Dest))) |
| i-- |
| dAtA[i] = 0x1a |
| } |
| if len(m.Selector) > 0 { |
| i -= len(m.Selector) |
| copy(dAtA[i:], m.Selector) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.Selector))) |
| i-- |
| dAtA[i] = 0x12 |
| } |
| if m.Input != 0 { |
| i = encodeVarintOps(dAtA, i, uint64(m.Input)) |
| i-- |
| dAtA[i] = 0x8 |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *CacheOpt) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *CacheOpt) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *CacheOpt) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.Sharing != 0 { |
| i = encodeVarintOps(dAtA, i, uint64(m.Sharing)) |
| i-- |
| dAtA[i] = 0x10 |
| } |
| if len(m.ID) > 0 { |
| i -= len(m.ID) |
| copy(dAtA[i:], m.ID) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.ID))) |
| i-- |
| dAtA[i] = 0xa |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *SecretOpt) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *SecretOpt) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *SecretOpt) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.Optional { |
| i-- |
| if m.Optional { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i-- |
| dAtA[i] = 0x28 |
| } |
| if m.Mode != 0 { |
| i = encodeVarintOps(dAtA, i, uint64(m.Mode)) |
| i-- |
| dAtA[i] = 0x20 |
| } |
| if m.Gid != 0 { |
| i = encodeVarintOps(dAtA, i, uint64(m.Gid)) |
| i-- |
| dAtA[i] = 0x18 |
| } |
| if m.Uid != 0 { |
| i = encodeVarintOps(dAtA, i, uint64(m.Uid)) |
| i-- |
| dAtA[i] = 0x10 |
| } |
| if len(m.ID) > 0 { |
| i -= len(m.ID) |
| copy(dAtA[i:], m.ID) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.ID))) |
| i-- |
| dAtA[i] = 0xa |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *SSHOpt) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *SSHOpt) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *SSHOpt) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.Optional { |
| i-- |
| if m.Optional { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i-- |
| dAtA[i] = 0x28 |
| } |
| if m.Mode != 0 { |
| i = encodeVarintOps(dAtA, i, uint64(m.Mode)) |
| i-- |
| dAtA[i] = 0x20 |
| } |
| if m.Gid != 0 { |
| i = encodeVarintOps(dAtA, i, uint64(m.Gid)) |
| i-- |
| dAtA[i] = 0x18 |
| } |
| if m.Uid != 0 { |
| i = encodeVarintOps(dAtA, i, uint64(m.Uid)) |
| i-- |
| dAtA[i] = 0x10 |
| } |
| if len(m.ID) > 0 { |
| i -= len(m.ID) |
| copy(dAtA[i:], m.ID) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.ID))) |
| i-- |
| dAtA[i] = 0xa |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *SourceOp) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *SourceOp) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *SourceOp) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if len(m.Attrs) > 0 { |
| keysForAttrs := make([]string, 0, len(m.Attrs)) |
| for k := range m.Attrs { |
| keysForAttrs = append(keysForAttrs, string(k)) |
| } |
| github_com_gogo_protobuf_sortkeys.Strings(keysForAttrs) |
| for iNdEx := len(keysForAttrs) - 1; iNdEx >= 0; iNdEx-- { |
| v := m.Attrs[string(keysForAttrs[iNdEx])] |
| baseI := i |
| i -= len(v) |
| copy(dAtA[i:], v) |
| i = encodeVarintOps(dAtA, i, uint64(len(v))) |
| i-- |
| dAtA[i] = 0x12 |
| i -= len(keysForAttrs[iNdEx]) |
| copy(dAtA[i:], keysForAttrs[iNdEx]) |
| i = encodeVarintOps(dAtA, i, uint64(len(keysForAttrs[iNdEx]))) |
| i-- |
| dAtA[i] = 0xa |
| i = encodeVarintOps(dAtA, i, uint64(baseI-i)) |
| i-- |
| dAtA[i] = 0x12 |
| } |
| } |
| if len(m.Identifier) > 0 { |
| i -= len(m.Identifier) |
| copy(dAtA[i:], m.Identifier) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.Identifier))) |
| i-- |
| dAtA[i] = 0xa |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *BuildOp) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *BuildOp) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *BuildOp) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if len(m.Attrs) > 0 { |
| keysForAttrs := make([]string, 0, len(m.Attrs)) |
| for k := range m.Attrs { |
| keysForAttrs = append(keysForAttrs, string(k)) |
| } |
| github_com_gogo_protobuf_sortkeys.Strings(keysForAttrs) |
| for iNdEx := len(keysForAttrs) - 1; iNdEx >= 0; iNdEx-- { |
| v := m.Attrs[string(keysForAttrs[iNdEx])] |
| baseI := i |
| i -= len(v) |
| copy(dAtA[i:], v) |
| i = encodeVarintOps(dAtA, i, uint64(len(v))) |
| i-- |
| dAtA[i] = 0x12 |
| i -= len(keysForAttrs[iNdEx]) |
| copy(dAtA[i:], keysForAttrs[iNdEx]) |
| i = encodeVarintOps(dAtA, i, uint64(len(keysForAttrs[iNdEx]))) |
| i-- |
| dAtA[i] = 0xa |
| i = encodeVarintOps(dAtA, i, uint64(baseI-i)) |
| i-- |
| dAtA[i] = 0x22 |
| } |
| } |
| if m.Def != nil { |
| { |
| size, err := m.Def.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x1a |
| } |
| if len(m.Inputs) > 0 { |
| keysForInputs := make([]string, 0, len(m.Inputs)) |
| for k := range m.Inputs { |
| keysForInputs = append(keysForInputs, string(k)) |
| } |
| github_com_gogo_protobuf_sortkeys.Strings(keysForInputs) |
| for iNdEx := len(keysForInputs) - 1; iNdEx >= 0; iNdEx-- { |
| v := m.Inputs[string(keysForInputs[iNdEx])] |
| baseI := i |
| if v != nil { |
| { |
| size, err := v.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| } |
| i -= len(keysForInputs[iNdEx]) |
| copy(dAtA[i:], keysForInputs[iNdEx]) |
| i = encodeVarintOps(dAtA, i, uint64(len(keysForInputs[iNdEx]))) |
| i-- |
| dAtA[i] = 0xa |
| i = encodeVarintOps(dAtA, i, uint64(baseI-i)) |
| i-- |
| dAtA[i] = 0x12 |
| } |
| } |
| if m.Builder != 0 { |
| i = encodeVarintOps(dAtA, i, uint64(m.Builder)) |
| i-- |
| dAtA[i] = 0x8 |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *BuildInput) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *BuildInput) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *BuildInput) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.Input != 0 { |
| i = encodeVarintOps(dAtA, i, uint64(m.Input)) |
| i-- |
| dAtA[i] = 0x8 |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *OpMetadata) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *OpMetadata) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *OpMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if len(m.Caps) > 0 { |
| keysForCaps := make([]string, 0, len(m.Caps)) |
| for k := range m.Caps { |
| keysForCaps = append(keysForCaps, string(k)) |
| } |
| github_com_gogo_protobuf_sortkeys.Strings(keysForCaps) |
| for iNdEx := len(keysForCaps) - 1; iNdEx >= 0; iNdEx-- { |
| v := m.Caps[github_com_moby_buildkit_util_apicaps.CapID(keysForCaps[iNdEx])] |
| baseI := i |
| i-- |
| if v { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i-- |
| dAtA[i] = 0x10 |
| i -= len(keysForCaps[iNdEx]) |
| copy(dAtA[i:], keysForCaps[iNdEx]) |
| i = encodeVarintOps(dAtA, i, uint64(len(keysForCaps[iNdEx]))) |
| i-- |
| dAtA[i] = 0xa |
| i = encodeVarintOps(dAtA, i, uint64(baseI-i)) |
| i-- |
| dAtA[i] = 0x2a |
| } |
| } |
| if m.ExportCache != nil { |
| { |
| size, err := m.ExportCache.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x22 |
| } |
| if len(m.Description) > 0 { |
| keysForDescription := make([]string, 0, len(m.Description)) |
| for k := range m.Description { |
| keysForDescription = append(keysForDescription, string(k)) |
| } |
| github_com_gogo_protobuf_sortkeys.Strings(keysForDescription) |
| for iNdEx := len(keysForDescription) - 1; iNdEx >= 0; iNdEx-- { |
| v := m.Description[string(keysForDescription[iNdEx])] |
| baseI := i |
| i -= len(v) |
| copy(dAtA[i:], v) |
| i = encodeVarintOps(dAtA, i, uint64(len(v))) |
| i-- |
| dAtA[i] = 0x12 |
| i -= len(keysForDescription[iNdEx]) |
| copy(dAtA[i:], keysForDescription[iNdEx]) |
| i = encodeVarintOps(dAtA, i, uint64(len(keysForDescription[iNdEx]))) |
| i-- |
| dAtA[i] = 0xa |
| i = encodeVarintOps(dAtA, i, uint64(baseI-i)) |
| i-- |
| dAtA[i] = 0x12 |
| } |
| } |
| if m.IgnoreCache { |
| i-- |
| if m.IgnoreCache { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i-- |
| dAtA[i] = 0x8 |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *Source) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *Source) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *Source) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if len(m.Infos) > 0 { |
| for iNdEx := len(m.Infos) - 1; iNdEx >= 0; iNdEx-- { |
| { |
| size, err := m.Infos[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| } |
| } |
| if len(m.Locations) > 0 { |
| keysForLocations := make([]string, 0, len(m.Locations)) |
| for k := range m.Locations { |
| keysForLocations = append(keysForLocations, string(k)) |
| } |
| github_com_gogo_protobuf_sortkeys.Strings(keysForLocations) |
| for iNdEx := len(keysForLocations) - 1; iNdEx >= 0; iNdEx-- { |
| v := m.Locations[string(keysForLocations[iNdEx])] |
| baseI := i |
| if v != nil { |
| { |
| size, err := v.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| } |
| i -= len(keysForLocations[iNdEx]) |
| copy(dAtA[i:], keysForLocations[iNdEx]) |
| i = encodeVarintOps(dAtA, i, uint64(len(keysForLocations[iNdEx]))) |
| i-- |
| dAtA[i] = 0xa |
| i = encodeVarintOps(dAtA, i, uint64(baseI-i)) |
| i-- |
| dAtA[i] = 0xa |
| } |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *Locations) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *Locations) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *Locations) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if len(m.Locations) > 0 { |
| for iNdEx := len(m.Locations) - 1; iNdEx >= 0; iNdEx-- { |
| { |
| size, err := m.Locations[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0xa |
| } |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *SourceInfo) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *SourceInfo) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *SourceInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.Definition != nil { |
| { |
| size, err := m.Definition.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x1a |
| } |
| if len(m.Data) > 0 { |
| i -= len(m.Data) |
| copy(dAtA[i:], m.Data) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.Data))) |
| i-- |
| dAtA[i] = 0x12 |
| } |
| if len(m.Filename) > 0 { |
| i -= len(m.Filename) |
| copy(dAtA[i:], m.Filename) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.Filename))) |
| i-- |
| dAtA[i] = 0xa |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *Location) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *Location) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *Location) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if len(m.Ranges) > 0 { |
| for iNdEx := len(m.Ranges) - 1; iNdEx >= 0; iNdEx-- { |
| { |
| size, err := m.Ranges[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| } |
| } |
| if m.SourceIndex != 0 { |
| i = encodeVarintOps(dAtA, i, uint64(m.SourceIndex)) |
| i-- |
| dAtA[i] = 0x8 |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *Range) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *Range) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *Range) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| { |
| size, err := m.End.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| { |
| size, err := m.Start.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0xa |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *Position) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *Position) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *Position) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.Character != 0 { |
| i = encodeVarintOps(dAtA, i, uint64(m.Character)) |
| i-- |
| dAtA[i] = 0x10 |
| } |
| if m.Line != 0 { |
| i = encodeVarintOps(dAtA, i, uint64(m.Line)) |
| i-- |
| dAtA[i] = 0x8 |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *ExportCache) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *ExportCache) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *ExportCache) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.Value { |
| i-- |
| if m.Value { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i-- |
| dAtA[i] = 0x8 |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *ProxyEnv) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *ProxyEnv) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *ProxyEnv) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if len(m.NoProxy) > 0 { |
| i -= len(m.NoProxy) |
| copy(dAtA[i:], m.NoProxy) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.NoProxy))) |
| i-- |
| dAtA[i] = 0x22 |
| } |
| if len(m.FtpProxy) > 0 { |
| i -= len(m.FtpProxy) |
| copy(dAtA[i:], m.FtpProxy) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.FtpProxy))) |
| i-- |
| dAtA[i] = 0x1a |
| } |
| if len(m.HttpsProxy) > 0 { |
| i -= len(m.HttpsProxy) |
| copy(dAtA[i:], m.HttpsProxy) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.HttpsProxy))) |
| i-- |
| dAtA[i] = 0x12 |
| } |
| if len(m.HttpProxy) > 0 { |
| i -= len(m.HttpProxy) |
| copy(dAtA[i:], m.HttpProxy) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.HttpProxy))) |
| i-- |
| dAtA[i] = 0xa |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *WorkerConstraints) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *WorkerConstraints) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *WorkerConstraints) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if len(m.Filter) > 0 { |
| for iNdEx := len(m.Filter) - 1; iNdEx >= 0; iNdEx-- { |
| i -= len(m.Filter[iNdEx]) |
| copy(dAtA[i:], m.Filter[iNdEx]) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.Filter[iNdEx]))) |
| i-- |
| dAtA[i] = 0xa |
| } |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *Definition) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *Definition) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *Definition) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.Source != nil { |
| { |
| size, err := m.Source.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x1a |
| } |
| if len(m.Metadata) > 0 { |
| keysForMetadata := make([]string, 0, len(m.Metadata)) |
| for k := range m.Metadata { |
| keysForMetadata = append(keysForMetadata, string(k)) |
| } |
| github_com_gogo_protobuf_sortkeys.Strings(keysForMetadata) |
| for iNdEx := len(keysForMetadata) - 1; iNdEx >= 0; iNdEx-- { |
| v := m.Metadata[github_com_opencontainers_go_digest.Digest(keysForMetadata[iNdEx])] |
| baseI := i |
| { |
| size, err := (&v).MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| i -= len(keysForMetadata[iNdEx]) |
| copy(dAtA[i:], keysForMetadata[iNdEx]) |
| i = encodeVarintOps(dAtA, i, uint64(len(keysForMetadata[iNdEx]))) |
| i-- |
| dAtA[i] = 0xa |
| i = encodeVarintOps(dAtA, i, uint64(baseI-i)) |
| i-- |
| dAtA[i] = 0x12 |
| } |
| } |
| if len(m.Def) > 0 { |
| for iNdEx := len(m.Def) - 1; iNdEx >= 0; iNdEx-- { |
| i -= len(m.Def[iNdEx]) |
| copy(dAtA[i:], m.Def[iNdEx]) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.Def[iNdEx]))) |
| i-- |
| dAtA[i] = 0xa |
| } |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *HostIP) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *HostIP) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *HostIP) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if len(m.IP) > 0 { |
| i -= len(m.IP) |
| copy(dAtA[i:], m.IP) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.IP))) |
| i-- |
| dAtA[i] = 0x12 |
| } |
| if len(m.Host) > 0 { |
| i -= len(m.Host) |
| copy(dAtA[i:], m.Host) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.Host))) |
| i-- |
| dAtA[i] = 0xa |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *FileOp) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *FileOp) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *FileOp) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if len(m.Actions) > 0 { |
| for iNdEx := len(m.Actions) - 1; iNdEx >= 0; iNdEx-- { |
| { |
| size, err := m.Actions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| } |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *FileAction) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *FileAction) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *FileAction) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.Action != nil { |
| { |
| size := m.Action.Size() |
| i -= size |
| if _, err := m.Action.MarshalTo(dAtA[i:]); err != nil { |
| return 0, err |
| } |
| } |
| } |
| if m.Output != 0 { |
| i = encodeVarintOps(dAtA, i, uint64(m.Output)) |
| i-- |
| dAtA[i] = 0x18 |
| } |
| if m.SecondaryInput != 0 { |
| i = encodeVarintOps(dAtA, i, uint64(m.SecondaryInput)) |
| i-- |
| dAtA[i] = 0x10 |
| } |
| if m.Input != 0 { |
| i = encodeVarintOps(dAtA, i, uint64(m.Input)) |
| i-- |
| dAtA[i] = 0x8 |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *FileAction_Copy) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *FileAction_Copy) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| if m.Copy != nil { |
| { |
| size, err := m.Copy.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x22 |
| } |
| return len(dAtA) - i, nil |
| } |
| func (m *FileAction_Mkfile) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *FileAction_Mkfile) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| if m.Mkfile != nil { |
| { |
| size, err := m.Mkfile.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x2a |
| } |
| return len(dAtA) - i, nil |
| } |
| func (m *FileAction_Mkdir) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *FileAction_Mkdir) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| if m.Mkdir != nil { |
| { |
| size, err := m.Mkdir.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x32 |
| } |
| return len(dAtA) - i, nil |
| } |
| func (m *FileAction_Rm) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *FileAction_Rm) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| if m.Rm != nil { |
| { |
| size, err := m.Rm.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x3a |
| } |
| return len(dAtA) - i, nil |
| } |
| func (m *FileActionCopy) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *FileActionCopy) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *FileActionCopy) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.Timestamp != 0 { |
| i = encodeVarintOps(dAtA, i, uint64(m.Timestamp)) |
| i-- |
| dAtA[i] = 0x58 |
| } |
| if m.AllowEmptyWildcard { |
| i-- |
| if m.AllowEmptyWildcard { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i-- |
| dAtA[i] = 0x50 |
| } |
| if m.AllowWildcard { |
| i-- |
| if m.AllowWildcard { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i-- |
| dAtA[i] = 0x48 |
| } |
| if m.CreateDestPath { |
| i-- |
| if m.CreateDestPath { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i-- |
| dAtA[i] = 0x40 |
| } |
| if m.AttemptUnpackDockerCompatibility { |
| i-- |
| if m.AttemptUnpackDockerCompatibility { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i-- |
| dAtA[i] = 0x38 |
| } |
| if m.DirCopyContents { |
| i-- |
| if m.DirCopyContents { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i-- |
| dAtA[i] = 0x30 |
| } |
| if m.FollowSymlink { |
| i-- |
| if m.FollowSymlink { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i-- |
| dAtA[i] = 0x28 |
| } |
| if m.Mode != 0 { |
| i = encodeVarintOps(dAtA, i, uint64(m.Mode)) |
| i-- |
| dAtA[i] = 0x20 |
| } |
| if m.Owner != nil { |
| { |
| size, err := m.Owner.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x1a |
| } |
| if len(m.Dest) > 0 { |
| i -= len(m.Dest) |
| copy(dAtA[i:], m.Dest) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.Dest))) |
| i-- |
| dAtA[i] = 0x12 |
| } |
| if len(m.Src) > 0 { |
| i -= len(m.Src) |
| copy(dAtA[i:], m.Src) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.Src))) |
| i-- |
| dAtA[i] = 0xa |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *FileActionMkFile) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *FileActionMkFile) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *FileActionMkFile) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.Timestamp != 0 { |
| i = encodeVarintOps(dAtA, i, uint64(m.Timestamp)) |
| i-- |
| dAtA[i] = 0x28 |
| } |
| if m.Owner != nil { |
| { |
| size, err := m.Owner.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x22 |
| } |
| if len(m.Data) > 0 { |
| i -= len(m.Data) |
| copy(dAtA[i:], m.Data) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.Data))) |
| i-- |
| dAtA[i] = 0x1a |
| } |
| if m.Mode != 0 { |
| i = encodeVarintOps(dAtA, i, uint64(m.Mode)) |
| i-- |
| dAtA[i] = 0x10 |
| } |
| if len(m.Path) > 0 { |
| i -= len(m.Path) |
| copy(dAtA[i:], m.Path) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.Path))) |
| i-- |
| dAtA[i] = 0xa |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *FileActionMkDir) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *FileActionMkDir) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *FileActionMkDir) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.Timestamp != 0 { |
| i = encodeVarintOps(dAtA, i, uint64(m.Timestamp)) |
| i-- |
| dAtA[i] = 0x28 |
| } |
| if m.Owner != nil { |
| { |
| size, err := m.Owner.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x22 |
| } |
| if m.MakeParents { |
| i-- |
| if m.MakeParents { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i-- |
| dAtA[i] = 0x18 |
| } |
| if m.Mode != 0 { |
| i = encodeVarintOps(dAtA, i, uint64(m.Mode)) |
| i-- |
| dAtA[i] = 0x10 |
| } |
| if len(m.Path) > 0 { |
| i -= len(m.Path) |
| copy(dAtA[i:], m.Path) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.Path))) |
| i-- |
| dAtA[i] = 0xa |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *FileActionRm) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *FileActionRm) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *FileActionRm) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.AllowWildcard { |
| i-- |
| if m.AllowWildcard { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i-- |
| dAtA[i] = 0x18 |
| } |
| if m.AllowNotFound { |
| i-- |
| if m.AllowNotFound { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i-- |
| dAtA[i] = 0x10 |
| } |
| if len(m.Path) > 0 { |
| i -= len(m.Path) |
| copy(dAtA[i:], m.Path) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.Path))) |
| i-- |
| dAtA[i] = 0xa |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *ChownOpt) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *ChownOpt) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *ChownOpt) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.Group != nil { |
| { |
| size, err := m.Group.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| } |
| if m.User != nil { |
| { |
| size, err := m.User.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0xa |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *UserOpt) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *UserOpt) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *UserOpt) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.User != nil { |
| { |
| size := m.User.Size() |
| i -= size |
| if _, err := m.User.MarshalTo(dAtA[i:]); err != nil { |
| return 0, err |
| } |
| } |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *UserOpt_ByName) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *UserOpt_ByName) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| if m.ByName != nil { |
| { |
| size, err := m.ByName.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintOps(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0xa |
| } |
| return len(dAtA) - i, nil |
| } |
| func (m *UserOpt_ByID) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *UserOpt_ByID) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| i = encodeVarintOps(dAtA, i, uint64(m.ByID)) |
| i-- |
| dAtA[i] = 0x10 |
| return len(dAtA) - i, nil |
| } |
| func (m *NamedUserOpt) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *NamedUserOpt) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *NamedUserOpt) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.Input != 0 { |
| i = encodeVarintOps(dAtA, i, uint64(m.Input)) |
| i-- |
| dAtA[i] = 0x10 |
| } |
| if len(m.Name) > 0 { |
| i -= len(m.Name) |
| copy(dAtA[i:], m.Name) |
| i = encodeVarintOps(dAtA, i, uint64(len(m.Name))) |
| i-- |
| dAtA[i] = 0xa |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func encodeVarintOps(dAtA []byte, offset int, v uint64) int { |
| offset -= sovOps(v) |
| base := offset |
| for v >= 1<<7 { |
| dAtA[offset] = uint8(v&0x7f | 0x80) |
| v >>= 7 |
| offset++ |
| } |
| dAtA[offset] = uint8(v) |
| return base |
| } |
| func (m *Op) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if len(m.Inputs) > 0 { |
| for _, e := range m.Inputs { |
| l = e.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| } |
| if m.Op != nil { |
| n += m.Op.Size() |
| } |
| if m.Platform != nil { |
| l = m.Platform.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| if m.Constraints != nil { |
| l = m.Constraints.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| return n |
| } |
| |
| func (m *Op_Exec) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.Exec != nil { |
| l = m.Exec.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| return n |
| } |
| func (m *Op_Source) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.Source != nil { |
| l = m.Source.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| return n |
| } |
| func (m *Op_File) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.File != nil { |
| l = m.File.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| return n |
| } |
| func (m *Op_Build) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.Build != nil { |
| l = m.Build.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| return n |
| } |
| func (m *Platform) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.Architecture) |
| if l > 0 { |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| l = len(m.OS) |
| if l > 0 { |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| l = len(m.Variant) |
| if l > 0 { |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| l = len(m.OSVersion) |
| if l > 0 { |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| if len(m.OSFeatures) > 0 { |
| for _, s := range m.OSFeatures { |
| l = len(s) |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| } |
| return n |
| } |
| |
| func (m *Input) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.Digest) |
| if l > 0 { |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| if m.Index != 0 { |
| n += 1 + sovOps(uint64(m.Index)) |
| } |
| return n |
| } |
| |
| func (m *ExecOp) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.Meta != nil { |
| l = m.Meta.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| if len(m.Mounts) > 0 { |
| for _, e := range m.Mounts { |
| l = e.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| } |
| if m.Network != 0 { |
| n += 1 + sovOps(uint64(m.Network)) |
| } |
| if m.Security != 0 { |
| n += 1 + sovOps(uint64(m.Security)) |
| } |
| return n |
| } |
| |
| func (m *Meta) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if len(m.Args) > 0 { |
| for _, s := range m.Args { |
| l = len(s) |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| } |
| if len(m.Env) > 0 { |
| for _, s := range m.Env { |
| l = len(s) |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| } |
| l = len(m.Cwd) |
| if l > 0 { |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| l = len(m.User) |
| if l > 0 { |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| if m.ProxyEnv != nil { |
| l = m.ProxyEnv.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| if len(m.ExtraHosts) > 0 { |
| for _, e := range m.ExtraHosts { |
| l = e.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| } |
| l = len(m.Hostname) |
| if l > 0 { |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| return n |
| } |
| |
| func (m *Mount) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.Input != 0 { |
| n += 1 + sovOps(uint64(m.Input)) |
| } |
| l = len(m.Selector) |
| if l > 0 { |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| l = len(m.Dest) |
| if l > 0 { |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| if m.Output != 0 { |
| n += 1 + sovOps(uint64(m.Output)) |
| } |
| if m.Readonly { |
| n += 2 |
| } |
| if m.MountType != 0 { |
| n += 1 + sovOps(uint64(m.MountType)) |
| } |
| if m.CacheOpt != nil { |
| l = m.CacheOpt.Size() |
| n += 2 + l + sovOps(uint64(l)) |
| } |
| if m.SecretOpt != nil { |
| l = m.SecretOpt.Size() |
| n += 2 + l + sovOps(uint64(l)) |
| } |
| if m.SSHOpt != nil { |
| l = m.SSHOpt.Size() |
| n += 2 + l + sovOps(uint64(l)) |
| } |
| l = len(m.ResultID) |
| if l > 0 { |
| n += 2 + l + sovOps(uint64(l)) |
| } |
| return n |
| } |
| |
| func (m *CacheOpt) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.ID) |
| if l > 0 { |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| if m.Sharing != 0 { |
| n += 1 + sovOps(uint64(m.Sharing)) |
| } |
| return n |
| } |
| |
| func (m *SecretOpt) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.ID) |
| if l > 0 { |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| if m.Uid != 0 { |
| n += 1 + sovOps(uint64(m.Uid)) |
| } |
| if m.Gid != 0 { |
| n += 1 + sovOps(uint64(m.Gid)) |
| } |
| if m.Mode != 0 { |
| n += 1 + sovOps(uint64(m.Mode)) |
| } |
| if m.Optional { |
| n += 2 |
| } |
| return n |
| } |
| |
| func (m *SSHOpt) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.ID) |
| if l > 0 { |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| if m.Uid != 0 { |
| n += 1 + sovOps(uint64(m.Uid)) |
| } |
| if m.Gid != 0 { |
| n += 1 + sovOps(uint64(m.Gid)) |
| } |
| if m.Mode != 0 { |
| n += 1 + sovOps(uint64(m.Mode)) |
| } |
| if m.Optional { |
| n += 2 |
| } |
| return n |
| } |
| |
| func (m *SourceOp) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.Identifier) |
| if l > 0 { |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| if len(m.Attrs) > 0 { |
| for k, v := range m.Attrs { |
| _ = k |
| _ = v |
| mapEntrySize := 1 + len(k) + sovOps(uint64(len(k))) + 1 + len(v) + sovOps(uint64(len(v))) |
| n += mapEntrySize + 1 + sovOps(uint64(mapEntrySize)) |
| } |
| } |
| return n |
| } |
| |
| func (m *BuildOp) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.Builder != 0 { |
| n += 1 + sovOps(uint64(m.Builder)) |
| } |
| if len(m.Inputs) > 0 { |
| for k, v := range m.Inputs { |
| _ = k |
| _ = v |
| l = 0 |
| if v != nil { |
| l = v.Size() |
| l += 1 + sovOps(uint64(l)) |
| } |
| mapEntrySize := 1 + len(k) + sovOps(uint64(len(k))) + l |
| n += mapEntrySize + 1 + sovOps(uint64(mapEntrySize)) |
| } |
| } |
| if m.Def != nil { |
| l = m.Def.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| if len(m.Attrs) > 0 { |
| for k, v := range m.Attrs { |
| _ = k |
| _ = v |
| mapEntrySize := 1 + len(k) + sovOps(uint64(len(k))) + 1 + len(v) + sovOps(uint64(len(v))) |
| n += mapEntrySize + 1 + sovOps(uint64(mapEntrySize)) |
| } |
| } |
| return n |
| } |
| |
| func (m *BuildInput) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.Input != 0 { |
| n += 1 + sovOps(uint64(m.Input)) |
| } |
| return n |
| } |
| |
| func (m *OpMetadata) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.IgnoreCache { |
| n += 2 |
| } |
| if len(m.Description) > 0 { |
| for k, v := range m.Description { |
| _ = k |
| _ = v |
| mapEntrySize := 1 + len(k) + sovOps(uint64(len(k))) + 1 + len(v) + sovOps(uint64(len(v))) |
| n += mapEntrySize + 1 + sovOps(uint64(mapEntrySize)) |
| } |
| } |
| if m.ExportCache != nil { |
| l = m.ExportCache.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| if len(m.Caps) > 0 { |
| for k, v := range m.Caps { |
| _ = k |
| _ = v |
| mapEntrySize := 1 + len(k) + sovOps(uint64(len(k))) + 1 + 1 |
| n += mapEntrySize + 1 + sovOps(uint64(mapEntrySize)) |
| } |
| } |
| return n |
| } |
| |
| func (m *Source) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if len(m.Locations) > 0 { |
| for k, v := range m.Locations { |
| _ = k |
| _ = v |
| l = 0 |
| if v != nil { |
| l = v.Size() |
| l += 1 + sovOps(uint64(l)) |
| } |
| mapEntrySize := 1 + len(k) + sovOps(uint64(len(k))) + l |
| n += mapEntrySize + 1 + sovOps(uint64(mapEntrySize)) |
| } |
| } |
| if len(m.Infos) > 0 { |
| for _, e := range m.Infos { |
| l = e.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| } |
| return n |
| } |
| |
| func (m *Locations) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if len(m.Locations) > 0 { |
| for _, e := range m.Locations { |
| l = e.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| } |
| return n |
| } |
| |
| func (m *SourceInfo) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.Filename) |
| if l > 0 { |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| l = len(m.Data) |
| if l > 0 { |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| if m.Definition != nil { |
| l = m.Definition.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| return n |
| } |
| |
| func (m *Location) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.SourceIndex != 0 { |
| n += 1 + sovOps(uint64(m.SourceIndex)) |
| } |
| if len(m.Ranges) > 0 { |
| for _, e := range m.Ranges { |
| l = e.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| } |
| return n |
| } |
| |
| func (m *Range) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = m.Start.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| l = m.End.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| return n |
| } |
| |
| func (m *Position) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.Line != 0 { |
| n += 1 + sovOps(uint64(m.Line)) |
| } |
| if m.Character != 0 { |
| n += 1 + sovOps(uint64(m.Character)) |
| } |
| return n |
| } |
| |
| func (m *ExportCache) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.Value { |
| n += 2 |
| } |
| return n |
| } |
| |
| func (m *ProxyEnv) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.HttpProxy) |
| if l > 0 { |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| l = len(m.HttpsProxy) |
| if l > 0 { |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| l = len(m.FtpProxy) |
| if l > 0 { |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| l = len(m.NoProxy) |
| if l > 0 { |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| return n |
| } |
| |
| func (m *WorkerConstraints) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if len(m.Filter) > 0 { |
| for _, s := range m.Filter { |
| l = len(s) |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| } |
| return n |
| } |
| |
| func (m *Definition) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if len(m.Def) > 0 { |
| for _, b := range m.Def { |
| l = len(b) |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| } |
| if len(m.Metadata) > 0 { |
| for k, v := range m.Metadata { |
| _ = k |
| _ = v |
| l = v.Size() |
| mapEntrySize := 1 + len(k) + sovOps(uint64(len(k))) + 1 + l + sovOps(uint64(l)) |
| n += mapEntrySize + 1 + sovOps(uint64(mapEntrySize)) |
| } |
| } |
| if m.Source != nil { |
| l = m.Source.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| return n |
| } |
| |
| func (m *HostIP) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.Host) |
| if l > 0 { |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| l = len(m.IP) |
| if l > 0 { |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| return n |
| } |
| |
| func (m *FileOp) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if len(m.Actions) > 0 { |
| for _, e := range m.Actions { |
| l = e.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| } |
| return n |
| } |
| |
| func (m *FileAction) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.Input != 0 { |
| n += 1 + sovOps(uint64(m.Input)) |
| } |
| if m.SecondaryInput != 0 { |
| n += 1 + sovOps(uint64(m.SecondaryInput)) |
| } |
| if m.Output != 0 { |
| n += 1 + sovOps(uint64(m.Output)) |
| } |
| if m.Action != nil { |
| n += m.Action.Size() |
| } |
| return n |
| } |
| |
| func (m *FileAction_Copy) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.Copy != nil { |
| l = m.Copy.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| return n |
| } |
| func (m *FileAction_Mkfile) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.Mkfile != nil { |
| l = m.Mkfile.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| return n |
| } |
| func (m *FileAction_Mkdir) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.Mkdir != nil { |
| l = m.Mkdir.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| return n |
| } |
| func (m *FileAction_Rm) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.Rm != nil { |
| l = m.Rm.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| return n |
| } |
| func (m *FileActionCopy) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.Src) |
| if l > 0 { |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| l = len(m.Dest) |
| if l > 0 { |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| if m.Owner != nil { |
| l = m.Owner.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| if m.Mode != 0 { |
| n += 1 + sovOps(uint64(m.Mode)) |
| } |
| if m.FollowSymlink { |
| n += 2 |
| } |
| if m.DirCopyContents { |
| n += 2 |
| } |
| if m.AttemptUnpackDockerCompatibility { |
| n += 2 |
| } |
| if m.CreateDestPath { |
| n += 2 |
| } |
| if m.AllowWildcard { |
| n += 2 |
| } |
| if m.AllowEmptyWildcard { |
| n += 2 |
| } |
| if m.Timestamp != 0 { |
| n += 1 + sovOps(uint64(m.Timestamp)) |
| } |
| return n |
| } |
| |
| func (m *FileActionMkFile) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.Path) |
| if l > 0 { |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| if m.Mode != 0 { |
| n += 1 + sovOps(uint64(m.Mode)) |
| } |
| l = len(m.Data) |
| if l > 0 { |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| if m.Owner != nil { |
| l = m.Owner.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| if m.Timestamp != 0 { |
| n += 1 + sovOps(uint64(m.Timestamp)) |
| } |
| return n |
| } |
| |
| func (m *FileActionMkDir) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.Path) |
| if l > 0 { |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| if m.Mode != 0 { |
| n += 1 + sovOps(uint64(m.Mode)) |
| } |
| if m.MakeParents { |
| n += 2 |
| } |
| if m.Owner != nil { |
| l = m.Owner.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| if m.Timestamp != 0 { |
| n += 1 + sovOps(uint64(m.Timestamp)) |
| } |
| return n |
| } |
| |
| func (m *FileActionRm) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.Path) |
| if l > 0 { |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| if m.AllowNotFound { |
| n += 2 |
| } |
| if m.AllowWildcard { |
| n += 2 |
| } |
| return n |
| } |
| |
| func (m *ChownOpt) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.User != nil { |
| l = m.User.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| if m.Group != nil { |
| l = m.Group.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| return n |
| } |
| |
| func (m *UserOpt) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.User != nil { |
| n += m.User.Size() |
| } |
| return n |
| } |
| |
| func (m *UserOpt_ByName) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.ByName != nil { |
| l = m.ByName.Size() |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| return n |
| } |
| func (m *UserOpt_ByID) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| n += 1 + sovOps(uint64(m.ByID)) |
| return n |
| } |
| func (m *NamedUserOpt) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.Name) |
| if l > 0 { |
| n += 1 + l + sovOps(uint64(l)) |
| } |
| if m.Input != 0 { |
| n += 1 + sovOps(uint64(m.Input)) |
| } |
| return n |
| } |
| |
| func sovOps(x uint64) (n int) { |
| return (math_bits.Len64(x|1) + 6) / 7 |
| } |
| func sozOps(x uint64) (n int) { |
| return sovOps(uint64((x << 1) ^ uint64((int64(x) >> 63)))) |
| } |
| func (m *Op) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: Op: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: Op: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Inputs", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Inputs = append(m.Inputs, &Input{}) |
| if err := m.Inputs[len(m.Inputs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Exec", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| v := &ExecOp{} |
| if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| m.Op = &Op_Exec{v} |
| iNdEx = postIndex |
| case 3: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| v := &SourceOp{} |
| if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| m.Op = &Op_Source{v} |
| iNdEx = postIndex |
| case 4: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field File", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| v := &FileOp{} |
| if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| m.Op = &Op_File{v} |
| iNdEx = postIndex |
| case 5: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Build", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| v := &BuildOp{} |
| if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| m.Op = &Op_Build{v} |
| iNdEx = postIndex |
| case 10: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Platform", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Platform == nil { |
| m.Platform = &Platform{} |
| } |
| if err := m.Platform.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 11: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Constraints", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Constraints == nil { |
| m.Constraints = &WorkerConstraints{} |
| } |
| if err := m.Constraints.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *Platform) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: Platform: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: Platform: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Architecture", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Architecture = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field OS", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.OS = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 3: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Variant", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Variant = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 4: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field OSVersion", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.OSVersion = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 5: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field OSFeatures", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.OSFeatures = append(m.OSFeatures, string(dAtA[iNdEx:postIndex])) |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *Input) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: Input: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: Input: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Digest", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Digest = github_com_opencontainers_go_digest.Digest(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) |
| } |
| m.Index = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Index |= OutputIndex(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *ExecOp) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: ExecOp: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: ExecOp: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Meta", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Meta == nil { |
| m.Meta = &Meta{} |
| } |
| if err := m.Meta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Mounts", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Mounts = append(m.Mounts, &Mount{}) |
| if err := m.Mounts[len(m.Mounts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 3: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Network", wireType) |
| } |
| m.Network = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Network |= NetMode(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 4: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Security", wireType) |
| } |
| m.Security = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Security |= SecurityMode(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *Meta) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: Meta: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: Meta: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Args", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Args = append(m.Args, string(dAtA[iNdEx:postIndex])) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Env", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Env = append(m.Env, string(dAtA[iNdEx:postIndex])) |
| iNdEx = postIndex |
| case 3: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Cwd", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Cwd = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 4: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field User", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.User = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 5: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ProxyEnv", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.ProxyEnv == nil { |
| m.ProxyEnv = &ProxyEnv{} |
| } |
| if err := m.ProxyEnv.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 6: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ExtraHosts", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.ExtraHosts = append(m.ExtraHosts, &HostIP{}) |
| if err := m.ExtraHosts[len(m.ExtraHosts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 7: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Hostname = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *Mount) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: Mount: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: Mount: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Input", wireType) |
| } |
| m.Input = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Input |= InputIndex(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Selector = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 3: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Dest", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Dest = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 4: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Output", wireType) |
| } |
| m.Output = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Output |= OutputIndex(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 5: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Readonly", wireType) |
| } |
| var v int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| v |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| m.Readonly = bool(v != 0) |
| case 6: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field MountType", wireType) |
| } |
| m.MountType = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.MountType |= MountType(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 20: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field CacheOpt", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.CacheOpt == nil { |
| m.CacheOpt = &CacheOpt{} |
| } |
| if err := m.CacheOpt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 21: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field SecretOpt", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.SecretOpt == nil { |
| m.SecretOpt = &SecretOpt{} |
| } |
| if err := m.SecretOpt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 22: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field SSHOpt", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.SSHOpt == nil { |
| m.SSHOpt = &SSHOpt{} |
| } |
| if err := m.SSHOpt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 23: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ResultID", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.ResultID = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *CacheOpt) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: CacheOpt: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: CacheOpt: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.ID = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Sharing", wireType) |
| } |
| m.Sharing = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Sharing |= CacheSharingOpt(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *SecretOpt) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: SecretOpt: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: SecretOpt: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.ID = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Uid", wireType) |
| } |
| m.Uid = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Uid |= uint32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 3: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Gid", wireType) |
| } |
| m.Gid = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Gid |= uint32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 4: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType) |
| } |
| m.Mode = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Mode |= uint32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 5: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Optional", wireType) |
| } |
| var v int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| v |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| m.Optional = bool(v != 0) |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *SSHOpt) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: SSHOpt: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: SSHOpt: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.ID = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Uid", wireType) |
| } |
| m.Uid = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Uid |= uint32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 3: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Gid", wireType) |
| } |
| m.Gid = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Gid |= uint32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 4: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType) |
| } |
| m.Mode = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Mode |= uint32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 5: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Optional", wireType) |
| } |
| var v int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| v |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| m.Optional = bool(v != 0) |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *SourceOp) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: SourceOp: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: SourceOp: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Identifier", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Identifier = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Attrs", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Attrs == nil { |
| m.Attrs = make(map[string]string) |
| } |
| var mapkey string |
| var mapvalue string |
| for iNdEx < postIndex { |
| entryPreIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| if fieldNum == 1 { |
| var stringLenmapkey uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLenmapkey |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLenmapkey := int(stringLenmapkey) |
| if intStringLenmapkey < 0 { |
| return ErrInvalidLengthOps |
| } |
| postStringIndexmapkey := iNdEx + intStringLenmapkey |
| if postStringIndexmapkey < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postStringIndexmapkey > l { |
| return io.ErrUnexpectedEOF |
| } |
| mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) |
| iNdEx = postStringIndexmapkey |
| } else if fieldNum == 2 { |
| var stringLenmapvalue uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLenmapvalue |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLenmapvalue := int(stringLenmapvalue) |
| if intStringLenmapvalue < 0 { |
| return ErrInvalidLengthOps |
| } |
| postStringIndexmapvalue := iNdEx + intStringLenmapvalue |
| if postStringIndexmapvalue < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postStringIndexmapvalue > l { |
| return io.ErrUnexpectedEOF |
| } |
| mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) |
| iNdEx = postStringIndexmapvalue |
| } else { |
| iNdEx = entryPreIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > postIndex { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| m.Attrs[mapkey] = mapvalue |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *BuildOp) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: BuildOp: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: BuildOp: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Builder", wireType) |
| } |
| m.Builder = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Builder |= InputIndex(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Inputs", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Inputs == nil { |
| m.Inputs = make(map[string]*BuildInput) |
| } |
| var mapkey string |
| var mapvalue *BuildInput |
| for iNdEx < postIndex { |
| entryPreIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| if fieldNum == 1 { |
| var stringLenmapkey uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLenmapkey |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLenmapkey := int(stringLenmapkey) |
| if intStringLenmapkey < 0 { |
| return ErrInvalidLengthOps |
| } |
| postStringIndexmapkey := iNdEx + intStringLenmapkey |
| if postStringIndexmapkey < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postStringIndexmapkey > l { |
| return io.ErrUnexpectedEOF |
| } |
| mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) |
| iNdEx = postStringIndexmapkey |
| } else if fieldNum == 2 { |
| var mapmsglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| mapmsglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if mapmsglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postmsgIndex := iNdEx + mapmsglen |
| if postmsgIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postmsgIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| mapvalue = &BuildInput{} |
| if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { |
| return err |
| } |
| iNdEx = postmsgIndex |
| } else { |
| iNdEx = entryPreIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > postIndex { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| m.Inputs[mapkey] = mapvalue |
| iNdEx = postIndex |
| case 3: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Def", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Def == nil { |
| m.Def = &Definition{} |
| } |
| if err := m.Def.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 4: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Attrs", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Attrs == nil { |
| m.Attrs = make(map[string]string) |
| } |
| var mapkey string |
| var mapvalue string |
| for iNdEx < postIndex { |
| entryPreIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| if fieldNum == 1 { |
| var stringLenmapkey uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLenmapkey |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLenmapkey := int(stringLenmapkey) |
| if intStringLenmapkey < 0 { |
| return ErrInvalidLengthOps |
| } |
| postStringIndexmapkey := iNdEx + intStringLenmapkey |
| if postStringIndexmapkey < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postStringIndexmapkey > l { |
| return io.ErrUnexpectedEOF |
| } |
| mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) |
| iNdEx = postStringIndexmapkey |
| } else if fieldNum == 2 { |
| var stringLenmapvalue uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLenmapvalue |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLenmapvalue := int(stringLenmapvalue) |
| if intStringLenmapvalue < 0 { |
| return ErrInvalidLengthOps |
| } |
| postStringIndexmapvalue := iNdEx + intStringLenmapvalue |
| if postStringIndexmapvalue < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postStringIndexmapvalue > l { |
| return io.ErrUnexpectedEOF |
| } |
| mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) |
| iNdEx = postStringIndexmapvalue |
| } else { |
| iNdEx = entryPreIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > postIndex { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| m.Attrs[mapkey] = mapvalue |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *BuildInput) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: BuildInput: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: BuildInput: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Input", wireType) |
| } |
| m.Input = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Input |= InputIndex(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *OpMetadata) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: OpMetadata: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: OpMetadata: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field IgnoreCache", wireType) |
| } |
| var v int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| v |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| m.IgnoreCache = bool(v != 0) |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Description == nil { |
| m.Description = make(map[string]string) |
| } |
| var mapkey string |
| var mapvalue string |
| for iNdEx < postIndex { |
| entryPreIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| if fieldNum == 1 { |
| var stringLenmapkey uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLenmapkey |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLenmapkey := int(stringLenmapkey) |
| if intStringLenmapkey < 0 { |
| return ErrInvalidLengthOps |
| } |
| postStringIndexmapkey := iNdEx + intStringLenmapkey |
| if postStringIndexmapkey < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postStringIndexmapkey > l { |
| return io.ErrUnexpectedEOF |
| } |
| mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) |
| iNdEx = postStringIndexmapkey |
| } else if fieldNum == 2 { |
| var stringLenmapvalue uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLenmapvalue |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLenmapvalue := int(stringLenmapvalue) |
| if intStringLenmapvalue < 0 { |
| return ErrInvalidLengthOps |
| } |
| postStringIndexmapvalue := iNdEx + intStringLenmapvalue |
| if postStringIndexmapvalue < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postStringIndexmapvalue > l { |
| return io.ErrUnexpectedEOF |
| } |
| mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) |
| iNdEx = postStringIndexmapvalue |
| } else { |
| iNdEx = entryPreIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > postIndex { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| m.Description[mapkey] = mapvalue |
| iNdEx = postIndex |
| case 4: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ExportCache", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.ExportCache == nil { |
| m.ExportCache = &ExportCache{} |
| } |
| if err := m.ExportCache.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 5: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Caps", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Caps == nil { |
| m.Caps = make(map[github_com_moby_buildkit_util_apicaps.CapID]bool) |
| } |
| var mapkey github_com_moby_buildkit_util_apicaps.CapID |
| var mapvalue bool |
| for iNdEx < postIndex { |
| entryPreIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| if fieldNum == 1 { |
| var stringLenmapkey uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLenmapkey |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLenmapkey := int(stringLenmapkey) |
| if intStringLenmapkey < 0 { |
| return ErrInvalidLengthOps |
| } |
| postStringIndexmapkey := iNdEx + intStringLenmapkey |
| if postStringIndexmapkey < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postStringIndexmapkey > l { |
| return io.ErrUnexpectedEOF |
| } |
| mapkey = github_com_moby_buildkit_util_apicaps.CapID(dAtA[iNdEx:postStringIndexmapkey]) |
| iNdEx = postStringIndexmapkey |
| } else if fieldNum == 2 { |
| var mapvaluetemp int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| mapvaluetemp |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| mapvalue = bool(mapvaluetemp != 0) |
| } else { |
| iNdEx = entryPreIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > postIndex { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| m.Caps[github_com_moby_buildkit_util_apicaps.CapID(mapkey)] = mapvalue |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *Source) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: Source: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: Source: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Locations", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Locations == nil { |
| m.Locations = make(map[string]*Locations) |
| } |
| var mapkey string |
| var mapvalue *Locations |
| for iNdEx < postIndex { |
| entryPreIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| if fieldNum == 1 { |
| var stringLenmapkey uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLenmapkey |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLenmapkey := int(stringLenmapkey) |
| if intStringLenmapkey < 0 { |
| return ErrInvalidLengthOps |
| } |
| postStringIndexmapkey := iNdEx + intStringLenmapkey |
| if postStringIndexmapkey < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postStringIndexmapkey > l { |
| return io.ErrUnexpectedEOF |
| } |
| mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) |
| iNdEx = postStringIndexmapkey |
| } else if fieldNum == 2 { |
| var mapmsglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| mapmsglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if mapmsglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postmsgIndex := iNdEx + mapmsglen |
| if postmsgIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postmsgIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| mapvalue = &Locations{} |
| if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { |
| return err |
| } |
| iNdEx = postmsgIndex |
| } else { |
| iNdEx = entryPreIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > postIndex { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| m.Locations[mapkey] = mapvalue |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Infos", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Infos = append(m.Infos, &SourceInfo{}) |
| if err := m.Infos[len(m.Infos)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *Locations) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: Locations: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: Locations: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Locations", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Locations = append(m.Locations, &Location{}) |
| if err := m.Locations[len(m.Locations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *SourceInfo) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: SourceInfo: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: SourceInfo: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Filename", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Filename = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) |
| } |
| var byteLen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| byteLen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if byteLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + byteLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) |
| if m.Data == nil { |
| m.Data = []byte{} |
| } |
| iNdEx = postIndex |
| case 3: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Definition", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Definition == nil { |
| m.Definition = &Definition{} |
| } |
| if err := m.Definition.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *Location) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: Location: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: Location: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field SourceIndex", wireType) |
| } |
| m.SourceIndex = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.SourceIndex |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Ranges = append(m.Ranges, &Range{}) |
| if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *Range) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: Range: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: Range: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if err := m.Start.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field End", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if err := m.End.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *Position) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: Position: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: Position: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Line", wireType) |
| } |
| m.Line = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Line |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 2: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Character", wireType) |
| } |
| m.Character = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Character |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *ExportCache) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: ExportCache: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: ExportCache: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) |
| } |
| var v int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| v |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| m.Value = bool(v != 0) |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *ProxyEnv) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: ProxyEnv: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: ProxyEnv: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field HttpProxy", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.HttpProxy = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field HttpsProxy", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.HttpsProxy = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 3: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field FtpProxy", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.FtpProxy = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 4: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field NoProxy", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.NoProxy = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *WorkerConstraints) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: WorkerConstraints: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: WorkerConstraints: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Filter", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Filter = append(m.Filter, string(dAtA[iNdEx:postIndex])) |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *Definition) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: Definition: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: Definition: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Def", wireType) |
| } |
| var byteLen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| byteLen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if byteLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + byteLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Def = append(m.Def, make([]byte, postIndex-iNdEx)) |
| copy(m.Def[len(m.Def)-1], dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Metadata == nil { |
| m.Metadata = make(map[github_com_opencontainers_go_digest.Digest]OpMetadata) |
| } |
| var mapkey github_com_opencontainers_go_digest.Digest |
| mapvalue := &OpMetadata{} |
| for iNdEx < postIndex { |
| entryPreIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| if fieldNum == 1 { |
| var stringLenmapkey uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLenmapkey |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLenmapkey := int(stringLenmapkey) |
| if intStringLenmapkey < 0 { |
| return ErrInvalidLengthOps |
| } |
| postStringIndexmapkey := iNdEx + intStringLenmapkey |
| if postStringIndexmapkey < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postStringIndexmapkey > l { |
| return io.ErrUnexpectedEOF |
| } |
| mapkey = github_com_opencontainers_go_digest.Digest(dAtA[iNdEx:postStringIndexmapkey]) |
| iNdEx = postStringIndexmapkey |
| } else if fieldNum == 2 { |
| var mapmsglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| mapmsglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if mapmsglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postmsgIndex := iNdEx + mapmsglen |
| if postmsgIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postmsgIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| mapvalue = &OpMetadata{} |
| if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { |
| return err |
| } |
| iNdEx = postmsgIndex |
| } else { |
| iNdEx = entryPreIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > postIndex { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| m.Metadata[github_com_opencontainers_go_digest.Digest(mapkey)] = *mapvalue |
| iNdEx = postIndex |
| case 3: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Source == nil { |
| m.Source = &Source{} |
| } |
| if err := m.Source.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *HostIP) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: HostIP: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: HostIP: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Host", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Host = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field IP", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.IP = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *FileOp) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: FileOp: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: FileOp: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Actions", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Actions = append(m.Actions, &FileAction{}) |
| if err := m.Actions[len(m.Actions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *FileAction) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: FileAction: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: FileAction: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Input", wireType) |
| } |
| m.Input = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Input |= InputIndex(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 2: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field SecondaryInput", wireType) |
| } |
| m.SecondaryInput = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.SecondaryInput |= InputIndex(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 3: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Output", wireType) |
| } |
| m.Output = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Output |= OutputIndex(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 4: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Copy", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| v := &FileActionCopy{} |
| if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| m.Action = &FileAction_Copy{v} |
| iNdEx = postIndex |
| case 5: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Mkfile", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| v := &FileActionMkFile{} |
| if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| m.Action = &FileAction_Mkfile{v} |
| iNdEx = postIndex |
| case 6: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Mkdir", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| v := &FileActionMkDir{} |
| if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| m.Action = &FileAction_Mkdir{v} |
| iNdEx = postIndex |
| case 7: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Rm", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| v := &FileActionRm{} |
| if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| m.Action = &FileAction_Rm{v} |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *FileActionCopy) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: FileActionCopy: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: FileActionCopy: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Src", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Src = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Dest", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Dest = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 3: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Owner == nil { |
| m.Owner = &ChownOpt{} |
| } |
| if err := m.Owner.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 4: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType) |
| } |
| m.Mode = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Mode |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 5: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field FollowSymlink", wireType) |
| } |
| var v int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| v |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| m.FollowSymlink = bool(v != 0) |
| case 6: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field DirCopyContents", wireType) |
| } |
| var v int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| v |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| m.DirCopyContents = bool(v != 0) |
| case 7: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field AttemptUnpackDockerCompatibility", wireType) |
| } |
| var v int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| v |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| m.AttemptUnpackDockerCompatibility = bool(v != 0) |
| case 8: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field CreateDestPath", wireType) |
| } |
| var v int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| v |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| m.CreateDestPath = bool(v != 0) |
| case 9: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field AllowWildcard", wireType) |
| } |
| var v int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| v |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| m.AllowWildcard = bool(v != 0) |
| case 10: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field AllowEmptyWildcard", wireType) |
| } |
| var v int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| v |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| m.AllowEmptyWildcard = bool(v != 0) |
| case 11: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) |
| } |
| m.Timestamp = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Timestamp |= int64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *FileActionMkFile) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: FileActionMkFile: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: FileActionMkFile: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Path = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType) |
| } |
| m.Mode = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Mode |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 3: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) |
| } |
| var byteLen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| byteLen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if byteLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + byteLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) |
| if m.Data == nil { |
| m.Data = []byte{} |
| } |
| iNdEx = postIndex |
| case 4: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Owner == nil { |
| m.Owner = &ChownOpt{} |
| } |
| if err := m.Owner.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 5: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) |
| } |
| m.Timestamp = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Timestamp |= int64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *FileActionMkDir) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: FileActionMkDir: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: FileActionMkDir: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Path = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType) |
| } |
| m.Mode = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Mode |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 3: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field MakeParents", wireType) |
| } |
| var v int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| v |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| m.MakeParents = bool(v != 0) |
| case 4: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Owner == nil { |
| m.Owner = &ChownOpt{} |
| } |
| if err := m.Owner.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 5: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) |
| } |
| m.Timestamp = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Timestamp |= int64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *FileActionRm) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: FileActionRm: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: FileActionRm: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Path = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field AllowNotFound", wireType) |
| } |
| var v int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| v |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| m.AllowNotFound = bool(v != 0) |
| case 3: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field AllowWildcard", wireType) |
| } |
| var v int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| v |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| m.AllowWildcard = bool(v != 0) |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *ChownOpt) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: ChownOpt: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: ChownOpt: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field User", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.User == nil { |
| m.User = &UserOpt{} |
| } |
| if err := m.User.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Group == nil { |
| m.Group = &UserOpt{} |
| } |
| if err := m.Group.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *UserOpt) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: UserOpt: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: UserOpt: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ByName", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| v := &NamedUserOpt{} |
| if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| m.User = &UserOpt_ByName{v} |
| iNdEx = postIndex |
| case 2: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ByID", wireType) |
| } |
| var v uint32 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| v |= uint32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| m.User = &UserOpt_ByID{v} |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *NamedUserOpt) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: NamedUserOpt: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: NamedUserOpt: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthOps |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex < 0 { |
| return ErrInvalidLengthOps |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Name = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Input", wireType) |
| } |
| m.Input = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Input |= InputIndex(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| default: |
| iNdEx = preIndex |
| skippy, err := skipOps(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthOps |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func skipOps(dAtA []byte) (n int, err error) { |
| l := len(dAtA) |
| iNdEx := 0 |
| depth := 0 |
| for iNdEx < l { |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return 0, ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return 0, io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| wireType := int(wire & 0x7) |
| switch wireType { |
| case 0: |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return 0, ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return 0, io.ErrUnexpectedEOF |
| } |
| iNdEx++ |
| if dAtA[iNdEx-1] < 0x80 { |
| break |
| } |
| } |
| case 1: |
| iNdEx += 8 |
| case 2: |
| var length int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return 0, ErrIntOverflowOps |
| } |
| if iNdEx >= l { |
| return 0, io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| length |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if length < 0 { |
| return 0, ErrInvalidLengthOps |
| } |
| iNdEx += length |
| case 3: |
| depth++ |
| case 4: |
| if depth == 0 { |
| return 0, ErrUnexpectedEndOfGroupOps |
| } |
| depth-- |
| case 5: |
| iNdEx += 4 |
| default: |
| return 0, fmt.Errorf("proto: illegal wireType %d", wireType) |
| } |
| if iNdEx < 0 { |
| return 0, ErrInvalidLengthOps |
| } |
| if depth == 0 { |
| return iNdEx, nil |
| } |
| } |
| return 0, io.ErrUnexpectedEOF |
| } |
| |
| var ( |
| ErrInvalidLengthOps = fmt.Errorf("proto: negative length found during unmarshaling") |
| ErrIntOverflowOps = fmt.Errorf("proto: integer overflow") |
| ErrUnexpectedEndOfGroupOps = fmt.Errorf("proto: unexpected end of group") |
| ) |