JohnHammond
/
buildkit
mirror of https://github.com/JohnHammond/buildkit.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #2411 from crazy-max/tpmfs-size 

add size to tmpfs mounts
master
Tõnis Tiigi 2021-10-18 13:26:44 -07:00 committed by GitHub
parent 9dd4ec0f48 32d95c8ece
commit 41c0a18147
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
18 changed files with 576 additions and 310 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
client/client_test.go
View File

@ -536,8 +536,10 @@ func testShmSize(t *testing.T, sb integration.Sandbox) {
require.NoError(t, err)
defer c.Close()
st := llb.Image("busybox:latest").
Run(llb.Shlex(`sh -c 'mount | grep /dev/shm > /out/out'`), llb.WithShmSize(128*1024))
st := llb.Image("busybox:latest").Run(
llb.AddMount("/dev/shm", llb.Scratch(), llb.Tmpfs(llb.TmpfsSize(128*1024))),
llb.Shlex(`sh -c 'mount | grep /dev/shm > /out/out'`),
)
out := st.AddMount("/out", llb.Scratch())
def, err := out.Marshal(sb.Context())

48
client/llb/exec.go
View File

@ -43,6 +43,7 @@ type mount struct {
selector string
cacheID string
tmpfs bool
tmpfsOpt TmpfsInfo
cacheSharing CacheMountSharingMode
noOutput bool
}
@ -205,14 +206,6 @@ func (e *ExecOp) Marshal(ctx context.Context, c *Constraints) (digest.Digest, []
meta.ExtraHosts = hosts
}
shmSize, err := getShmSize(e.base)(ctx, c)
if err != nil {
return "", nil, nil, nil, err
}
if shmSize != nil {
meta.ShmSize = *shmSize
}
ulimits, err := getUlimit(e.base)(ctx, c)
if err != nil {
return "", nil, nil, nil, err
@ -275,6 +268,9 @@ func (e *ExecOp) Marshal(ctx context.Context, c *Constraints) (digest.Digest, []
addCap(&e.constraints, pb.CapExecMountCacheSharing)
} else if m.tmpfs {
addCap(&e.constraints, pb.CapExecMountTmpfs)
if m.tmpfsOpt.Size > 0 {
addCap(&e.constraints, pb.CapExecMountTmpfsSize)
}
} else if m.source != nil {
addCap(&e.constraints, pb.CapExecMountBind)
}
@ -359,6 +355,9 @@ func (e *ExecOp) Marshal(ctx context.Context, c *Constraints) (digest.Digest, []
}
if m.tmpfs {
pm.MountType = pb.MountType_TMPFS
pm.TmpfsOpt = &pb.TmpfsOpt{
Size_: m.tmpfsOpt.Size,
}
}
peo.Mounts = append(peo.Mounts, pm)
}
@ -479,12 +478,37 @@ func AsPersistentCacheDir(id string, sharing CacheMountSharingMode) MountOption
}
}
func Tmpfs() MountOption {
func Tmpfs(opts ...TmpfsOption) MountOption {
return func(m *mount) {
t := &TmpfsInfo{}
for _, opt := range opts {
opt.SetTmpfsOption(t)
}
m.tmpfs = true
m.tmpfsOpt = *t
}
}
type TmpfsOption interface {
SetTmpfsOption(*TmpfsInfo)
}
type tmpfsOptionFunc func(*TmpfsInfo)
func (fn tmpfsOptionFunc) SetTmpfsOption(ti *TmpfsInfo) {
fn(ti)
}
func TmpfsSize(kb int64) TmpfsOption {
return tmpfsOptionFunc(func(ti *TmpfsInfo) {
ti.Size = kb
})
}
type TmpfsInfo struct {
Size int64
}
type RunOption interface {
SetRunOption(es *ExecInfo)
}
@ -524,12 +548,6 @@ func AddExtraHost(host string, ip net.IP) RunOption {
})
}
func WithShmSize(kb int64) RunOption {
return runOptionFunc(func(ei *ExecInfo) {
ei.State = ei.State.WithShmSize(kb)
})
}
func AddUlimit(name UlimitName, soft int64, hard int64) RunOption {
return runOptionFunc(func(ei *ExecInfo) {
ei.State = ei.State.AddUlimit(name, soft, hard)

21
client/llb/meta.go
View File

@ -20,7 +20,6 @@ var (
keyEnv = contextKeyT("llb.exec.env")
keyExtraHost = contextKeyT("llb.exec.extrahost")
keyHostname = contextKeyT("llb.exec.hostname")
keyShmSize = contextKeyT("llb.exec.shmsize")
keyUlimit = contextKeyT("llb.exec.ulimit")
keyUser = contextKeyT("llb.exec.user")
@ -235,26 +234,6 @@ type HostIP struct {
IP net.IP
}
func shmSize(kb int64) StateOption {
return func(s State) State {
return s.WithValue(keyShmSize, kb)
}
}
func getShmSize(s State) func(context.Context, *Constraints) (*int64, error) {
return func(ctx context.Context, c *Constraints) (*int64, error) {
v, err := s.getValue(keyShmSize)(ctx, c)
if err != nil {
return nil, err
}
if v != nil {
kb := v.(int64)
return &kb, nil
}
return nil, nil
}
}
func ulimit(name UlimitName, soft int64, hard int64) StateOption {
return func(s State) State {
return s.withValue(keyUlimit, func(ctx context.Context, c *Constraints) (interface{}, error) {

4
client/llb/state.go
View File

@ -397,10 +397,6 @@ func (s State) AddExtraHost(host string, ip net.IP) State {
return extraHost(host, ip)(s)
}
func (s State) WithShmSize(kb int64) State {
return shmSize(kb)(s)
}
func (s State) AddUlimit(name UlimitName, soft int64, hard int64) State {
return ulimit(name, soft, hard)(s)
}

1
executor/executor.go
View File

@ -18,7 +18,6 @@ type Meta struct {
Tty bool
ReadonlyRootFS bool
ExtraHosts []HostIP
ShmSize int64
Ulimit []*pb.Ulimit
NetMode pb.NetMode
SecurityMode pb.SecurityMode

14
executor/oci/mounts.go
View File

@ -100,3 +100,17 @@ func withBoundProc() oci.SpecOpts {
return nil
}
}
func dedupMounts(mnts []specs.Mount) []specs.Mount {
ret := make([]specs.Mount, 0, len(mnts))
visited := make(map[string]int)
for i, mnt := range mnts {
if j, ok := visited[mnt.Destination]; ok {
ret[j] = mnt
} else {
visited[mnt.Destination] = i
ret = append(ret, mnt)
}
}
return ret
}

135
executor/oci/mounts_test.go
View File

@ -8,8 +8,56 @@ import (
"github.com/moby/buildkit/util/appcontext"
specs "github.com/opencontainers/runtime-spec/specs-go"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
// The default mount-list from containerd
// https://github.com/containerd/containerd/blob/main/oci/mounts.go
var containerdDefMounts = []specs.Mount{
{
Destination: "/proc",
Type: "proc",
Source: "proc",
Options: []string{"nosuid", "noexec", "nodev"},
},
{
Destination: "/dev",
Type: "tmpfs",
Source: "tmpfs",
Options: []string{"nosuid", "strictatime", "mode=755", "size=65536k"},
},
{
Destination: "/dev/pts",
Type: "devpts",
Source: "devpts",
Options: []string{"nosuid", "noexec", "newinstance", "ptmxmode=0666", "mode=0620", "gid=5"},
},
{
Destination: "/dev/shm",
Type: "tmpfs",
Source: "shm",
Options: []string{"nosuid", "noexec", "nodev", "mode=1777", "size=65536k"},
},
{
Destination: "/dev/mqueue",
Type: "mqueue",
Source: "mqueue",
Options: []string{"nosuid", "noexec", "nodev"},
},
{
Destination: "/sys",
Type: "sysfs",
Source: "sysfs",
Options: []string{"nosuid", "noexec", "nodev", "ro"},
},
{
Destination: "/run",
Type: "tmpfs",
Source: "tmpfs",
Options: []string{"nosuid", "strictatime", "mode=755", "size=65536k"},
},
}
func TestHasPrefix(t *testing.T) {
type testCase struct {
path string
@ -99,52 +147,8 @@ func TestHasPrefix(t *testing.T) {
}
func TestWithRemovedMounts(t *testing.T) {
// The default mount-list from containerd
s := oci.Spec{
Mounts: []specs.Mount{
{
Destination: "/proc",
Type: "proc",
Source: "proc",
Options: []string{"nosuid", "noexec", "nodev"},
},
{
Destination: "/dev",
Type: "tmpfs",
Source: "tmpfs",
Options: []string{"nosuid", "strictatime", "mode=755", "size=65536k"},
},
{
Destination: "/dev/pts",
Type: "devpts",
Source: "devpts",
Options: []string{"nosuid", "noexec", "newinstance", "ptmxmode=0666", "mode=0620", "gid=5"},
},
{
Destination: "/dev/shm",
Type: "tmpfs",
Source: "shm",
Options: []string{"nosuid", "noexec", "nodev", "mode=1777", "size=65536k"},
},
{
Destination: "/dev/mqueue",
Type: "mqueue",
Source: "mqueue",
Options: []string{"nosuid", "noexec", "nodev"},
},
{
Destination: "/sys",
Type: "sysfs",
Source: "sysfs",
Options: []string{"nosuid", "noexec", "nodev", "ro"},
},
{
Destination: "/run",
Type: "tmpfs",
Source: "tmpfs",
Options: []string{"nosuid", "strictatime", "mode=755", "size=65536k"},
},
},
Mounts: containerdDefMounts,
}
oldLen := len(s.Mounts)
@ -152,3 +156,44 @@ func TestWithRemovedMounts(t *testing.T) {
assert.NoError(t, err)
assert.Equal(t, oldLen-1, len(s.Mounts))
}
func TestDedupMounts(t *testing.T) {
s := oci.Spec{
Mounts: append(containerdDefMounts, []specs.Mount{
{
Destination: "/dev/shm",
Type: "tmpfs",
Source: "shm",
Options: []string{"nosuid", "size=131072k"},
},
{
Destination: "/foo",
Type: "bind",
Source: "/bar",
Options: []string{"nosuid", "noexec", "nodev", "rbind", "ro"},
},
{
Destination: "/dev/mqueue",
Type: "mqueue",
Source: "mqueue",
Options: []string{"nosuid"},
},
}...),
}
mntsLen := len(s.Mounts)
s.Mounts = dedupMounts(s.Mounts)
require.Equal(t, mntsLen-2, len(s.Mounts))
assert.Equal(t, specs.Mount{
Destination: "/dev/shm",
Type: "tmpfs",
Source: "shm",
Options: []string{"nosuid", "size=131072k"},
}, s.Mounts[3])
assert.Equal(t, specs.Mount{
Destination: "/foo",
Type: "bind",
Source: "/bar",
Options: []string{"nosuid", "noexec", "nodev", "rbind", "ro"},
}, s.Mounts[len(s.Mounts)-1])
}

5
executor/oci/spec.go
View File

@ -97,10 +97,6 @@ func GenerateSpec(ctx context.Context, meta executor.Meta, mounts []executor.Mou
oci.WithHostname(hostname),
)
if meta.ShmSize > 0 {
opts = append(opts, oci.WithDevShmSize(meta.ShmSize))
}
s, err := oci.GenerateSpec(ctx, nil, c, opts...)
if err != nil {
return nil, nil, err
@ -168,6 +164,7 @@ func GenerateSpec(ctx context.Context, meta executor.Meta, mounts []executor.Mou
})
}
s.Mounts = dedupMounts(s.Mounts)
return s, releaseAll, nil
}

7
frontend/dockerfile/dockerfile2llb/convert.go
View File

@ -810,8 +810,11 @@ func dispatchRun(d *dispatchState, c *instructions.RunCommand, proxy *llb.ProxyE
for _, h := range dopt.extraHosts {
opt = append(opt, llb.AddExtraHost(h.Host, h.IP))
}
if dopt.shmSize > 0 {
opt = append(opt, llb.WithShmSize(dopt.shmSize))
if dopt.llbCaps != nil && dopt.llbCaps.Supports(pb.CapExecMountTmpfsSize) == nil {
if dopt.shmSize > 0 {
opt = append(opt, llb.AddMount("/dev/shm", llb.Scratch(), llb.Tmpfs(llb.TmpfsSize(dopt.shmSize))))
}
}
d.state = d.state.Run(opt...).Root()

4
frontend/dockerfile/dockerfile2llb/convert_runmount.go
View File

@ -95,7 +95,9 @@ func dispatchRunMounts(d *dispatchState, c *instructions.RunCommand, sources []*
var mountOpts []llb.MountOption
if mount.Type == instructions.MountTypeTmpfs {
st = llb.Scratch()
mountOpts = append(mountOpts, llb.Tmpfs())
mountOpts = append(mountOpts, llb.Tmpfs(
llb.TmpfsSize(mount.SizeLimit),
))
}
if mount.Type == instructions.MountTypeSecret {
secret, err := dispatchSecret(mount)

1
frontend/dockerfile/docs/syntax.md
View File

@ -96,6 +96,7 @@ This mount type allows mounting tmpfs in the build container.
|Option |Description|
|---------------------|-----------|
|`target` (required) | Mount path.|
|`size` | Specify an upper limit on the size of the filesystem.|
### `RUN --mount=type=secret`

11
frontend/dockerfile/instructions/commands_runmount.go
View File

@ -123,6 +123,7 @@ type Mount struct {
Source string
Target string
ReadOnly bool
SizeLimit int64
CacheID string
CacheSharing string
Required bool
@ -227,6 +228,16 @@ func parseMount(value string, expander SingleWordExpander) (*Mount, error) {
} else {
return nil, errors.Errorf("unexpected key '%s' for mount type '%s'", key, m.Type)
}
case "size":
if m.Type == "tmpfs" {
v, err := strconv.ParseInt(value, 10, 64)
if err != nil {
return nil, errors.Errorf("invalid value for %s: %s", key, value)
}
m.SizeLimit = v
} else {
return nil, errors.Errorf("unexpected key '%s' for mount type '%s'", key, m.Type)
}
case "id":
m.CacheID = value
case "sharing":

2
frontend/gateway/container.go
View File

@ -211,7 +211,7 @@ func PrepareMounts(ctx context.Context, mm *mounts.MountManager, cm cache.Manage
}
case opspb.MountType_TMPFS:
mountable = mm.MountableTmpFS()
mountable = mm.MountableTmpFS(m)
case opspb.MountType_SECRET:
var err error
mountable, err = mm.MountableSecret(ctx, m, g)

17
solver/llbsolver/mounts/mount.go
View File

@ -369,8 +369,8 @@ func (mm *MountManager) MountableCache(ctx context.Context, m *pb.Mount, ref cac
return mm.getRefCacheDir(ctx, ref, m.CacheOpt.ID, m, m.CacheOpt.Sharing, g)
}
func (mm *MountManager) MountableTmpFS() cache.Mountable {
return newTmpfs(mm.cm.IdentityMapping())
func (mm *MountManager) MountableTmpFS(m *pb.Mount) cache.Mountable {
return newTmpfs(mm.cm.IdentityMapping(), m.TmpfsOpt)
}
func (mm *MountManager) MountableSecret(ctx context.Context, m *pb.Mount, g session.Group) (cache.Mountable, error) {
@ -381,21 +381,23 @@ func (mm *MountManager) MountableSSH(ctx context.Context, m *pb.Mount, g session
return mm.getSSHMountable(ctx, m, g)
}
func newTmpfs(idmap *idtools.IdentityMapping) cache.Mountable {
return &tmpfs{idmap: idmap}
func newTmpfs(idmap *idtools.IdentityMapping, opt *pb.TmpfsOpt) cache.Mountable {
return &tmpfs{idmap: idmap, opt: opt}
}
type tmpfs struct {
idmap *idtools.IdentityMapping
opt *pb.TmpfsOpt
}
func (f *tmpfs) Mount(ctx context.Context, readonly bool, g session.Group) (snapshot.Mountable, error) {
return &tmpfsMount{readonly: readonly, idmap: f.idmap}, nil
return &tmpfsMount{readonly: readonly, idmap: f.idmap, opt: f.opt}, nil
}
type tmpfsMount struct {
readonly bool
idmap *idtools.IdentityMapping
opt *pb.TmpfsOpt
}
func (m *tmpfsMount) Mount() ([]mount.Mount, func() error, error) {
@ -403,6 +405,11 @@ func (m *tmpfsMount) Mount() ([]mount.Mount, func() error, error) {
if m.readonly {
opt = append(opt, "ro")
}
if m.opt != nil {
if m.opt.Size_ > 0 {
opt = append(opt, fmt.Sprintf("size=%dk", m.opt.Size_))
}
}
return []mount.Mount{{
Type: "tmpfs",
Source: "tmpfs",

1
solver/llbsolver/ops/exec.go
View File

@ -315,7 +315,6 @@ func (e *execOp) Exec(ctx context.Context, g session.Group, inputs []solver.Resu
Hostname: e.op.Meta.Hostname,
ReadonlyRootFS: p.ReadonlyRootFS,
ExtraHosts: extraHosts,
ShmSize: e.op.Meta.ShmSize,
Ulimit: e.op.Meta.Ulimit,
NetMode: e.op.Network,
SecurityMode: e.op.Security,

7
solver/pb/caps.go
View File

@ -48,6 +48,7 @@ const (
CapExecMountCacheSharing apicaps.CapID = "exec.mount.cache.sharing"
CapExecMountSelector apicaps.CapID = "exec.mount.selector"
CapExecMountTmpfs apicaps.CapID = "exec.mount.tmpfs"
CapExecMountTmpfsSize apicaps.CapID = "exec.mount.tmpfs.size"
CapExecMountSecret apicaps.CapID = "exec.mount.secret"
CapExecMountSSH apicaps.CapID = "exec.mount.ssh"
CapExecCgroupsMounted apicaps.CapID = "exec.cgroup"
@ -278,6 +279,12 @@ func init() {
Status: apicaps.CapStatusExperimental,
})
Caps.Init(apicaps.Cap{
ID: CapExecMountTmpfsSize,
Enabled: true,
Status: apicaps.CapStatusExperimental,
})
Caps.Init(apicaps.Cap{
ID: CapExecMountSecret,
Enabled: true,

594
solver/pb/ops.pb.go
View File

@ -468,7 +468,6 @@ type Meta struct {
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"`
ShmSize int64 `protobuf:"varint,8,opt,name=shmSize,proto3" json:"shmSize,omitempty"`
Ulimit []*Ulimit `protobuf:"bytes,9,rep,name=ulimit,proto3" json:"ulimit,omitempty"`
}
@ -550,13 +549,6 @@ func (m *Meta) GetHostname() string {
return ""
}
func (m *Meta) GetShmSize() int64 {
if m != nil {
return m.ShmSize
}
return 0
}
func (m *Meta) GetUlimit() []*Ulimit {
if m != nil {
return m.Ulimit
@ -676,6 +668,7 @@ type Mount struct {
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"`
TmpfsOpt *TmpfsOpt `protobuf:"bytes,19,opt,name=TmpfsOpt,proto3" json:"TmpfsOpt,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"`
@ -739,6 +732,13 @@ func (m *Mount) GetMountType() MountType {
return MountType_BIND
}
func (m *Mount) GetTmpfsOpt() *TmpfsOpt {
if m != nil {
return m.TmpfsOpt
}
return nil
}
func (m *Mount) GetCacheOpt() *CacheOpt {
if m != nil {
return m.CacheOpt
@ -767,6 +767,48 @@ func (m *Mount) GetResultID() string {
return ""
}
// TmpfsOpt defines options describing tpmfs mounts
type TmpfsOpt struct {
// Specify an upper limit on the size of the filesystem.
Size_ int64 `protobuf:"varint,1,opt,name=size,proto3" json:"size,omitempty"`
}
func (m *TmpfsOpt) Reset() { *m = TmpfsOpt{} }
func (m *TmpfsOpt) String() string { return proto.CompactTextString(m) }
func (*TmpfsOpt) ProtoMessage() {}
func (*TmpfsOpt) Descriptor() ([]byte, []int) {
return fileDescriptor_8de16154b2733812, []int{8}
}
func (m *TmpfsOpt) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *TmpfsOpt) 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 *TmpfsOpt) XXX_Merge(src proto.Message) {
xxx_messageInfo_TmpfsOpt.Merge(m, src)
}
func (m *TmpfsOpt) XXX_Size() int {
return m.Size()
}
func (m *TmpfsOpt) XXX_DiscardUnknown() {
xxx_messageInfo_TmpfsOpt.DiscardUnknown(m)
}
var xxx_messageInfo_TmpfsOpt proto.InternalMessageInfo
func (m *TmpfsOpt) GetSize_() int64 {
if m != nil {
return m.Size_
}
return 0
}
// CacheOpt defines options specific to cache mounts
type CacheOpt struct {
// ID is an optional namespace for the mount
@ -779,7 +821,7 @@ 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{8}
return fileDescriptor_8de16154b2733812, []int{9}
}
func (m *CacheOpt) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -837,7 +879,7 @@ 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{9}
return fileDescriptor_8de16154b2733812, []int{10}
}
func (m *SecretOpt) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -916,7 +958,7 @@ 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{10}
return fileDescriptor_8de16154b2733812, []int{11}
}
func (m *SSHOpt) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -989,7 +1031,7 @@ 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{11}
return fileDescriptor_8de16154b2733812, []int{12}
}
func (m *SourceOp) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1041,7 +1083,7 @@ 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{12}
return fileDescriptor_8de16154b2733812, []int{13}
}
func (m *BuildOp) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1096,7 +1138,7 @@ 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{13}
return fileDescriptor_8de16154b2733812, []int{14}
}
func (m *BuildInput) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1137,7 +1179,7 @@ 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{14}
return fileDescriptor_8de16154b2733812, []int{15}
}
func (m *OpMetadata) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1200,7 +1242,7 @@ 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{15}
return fileDescriptor_8de16154b2733812, []int{16}
}
func (m *Source) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1248,7 +1290,7 @@ 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{16}
return fileDescriptor_8de16154b2733812, []int{17}
}
func (m *Locations) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1291,7 +1333,7 @@ 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{17}
return fileDescriptor_8de16154b2733812, []int{18}
}
func (m *SourceInfo) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1347,7 +1389,7 @@ 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{18}
return fileDescriptor_8de16154b2733812, []int{19}
}
func (m *Location) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1396,7 +1438,7 @@ 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{19}
return fileDescriptor_8de16154b2733812, []int{20}
}
func (m *Range) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1445,7 +1487,7 @@ 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{20}
return fileDescriptor_8de16154b2733812, []int{21}
}
func (m *Position) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1492,7 +1534,7 @@ 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{21}
return fileDescriptor_8de16154b2733812, []int{22}
}
func (m *ExportCache) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1536,7 +1578,7 @@ 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{22}
return fileDescriptor_8de16154b2733812, []int{23}
}
func (m *ProxyEnv) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1605,7 +1647,7 @@ 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{23}
return fileDescriptor_8de16154b2733812, []int{24}
}
func (m *WorkerConstraints) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1652,7 +1694,7 @@ 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{24}
return fileDescriptor_8de16154b2733812, []int{25}
}
func (m *Definition) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1706,7 +1748,7 @@ 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{25}
return fileDescriptor_8de16154b2733812, []int{26}
}
func (m *FileOp) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1754,7 +1796,7 @@ 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{26}
return fileDescriptor_8de16154b2733812, []int{27}
}
func (m *FileAction) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1881,7 +1923,7 @@ 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{27}
return fileDescriptor_8de16154b2733812, []int{28}
}
func (m *FileActionCopy) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -2014,7 +2056,7 @@ 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{28}
return fileDescriptor_8de16154b2733812, []int{29}
}
func (m *FileActionMkFile) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -2091,7 +2133,7 @@ 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{29}
return fileDescriptor_8de16154b2733812, []int{30}
}
func (m *FileActionMkDir) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -2164,7 +2206,7 @@ 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{30}
return fileDescriptor_8de16154b2733812, []int{31}
}
func (m *FileActionRm) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -2219,7 +2261,7 @@ 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{31}
return fileDescriptor_8de16154b2733812, []int{32}
}
func (m *ChownOpt) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -2269,7 +2311,7 @@ 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{32}
return fileDescriptor_8de16154b2733812, []int{33}
}
func (m *UserOpt) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -2348,7 +2390,7 @@ 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{33}
return fileDescriptor_8de16154b2733812, []int{34}
}
func (m *NamedUserOpt) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -2393,6 +2435,7 @@ func init() {
proto.RegisterType((*HostIP)(nil), "pb.HostIP")
proto.RegisterType((*Ulimit)(nil), "pb.Ulimit")
proto.RegisterType((*Mount)(nil), "pb.Mount")
proto.RegisterType((*TmpfsOpt)(nil), "pb.TmpfsOpt")
proto.RegisterType((*CacheOpt)(nil), "pb.CacheOpt")
proto.RegisterType((*SecretOpt)(nil), "pb.SecretOpt")
proto.RegisterType((*SSHOpt)(nil), "pb.SSHOpt")
@ -2431,152 +2474,153 @@ func init() {
func init() { proto.RegisterFile("ops.proto", fileDescriptor_8de16154b2733812) }
var fileDescriptor_8de16154b2733812 = []byte{
// 2320 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0x4b, 0x6f, 0x1c, 0xc7,
0x11, 0xe6, 0xbe, 0x77, 0x6b, 0x97, 0xd4, 0xa6, 0x2d, 0xdb, 0x6b, 0x46, 0x21, 0xe9, 0xb1, 0x62,
0x50, 0x94, 0xb4, 0x04, 0x68, 0xc0, 0x32, 0x8c, 0x20, 0x08, 0xf7, 0x21, 0x70, 0x2d, 0x89, 0x4b,
0xf4, 0xea, 0x91, 0x9b, 0x30, 0x9c, 0xed, 0x25, 0x07, 0x9c, 0x99, 0x1e, 0xcc, 0xf4, 0x4a, 0xdc,
0x1c, 0x72, 0x70, 0xfe, 0x80, 0x81, 0x00, 0xb9, 0x25, 0x41, 0xfe, 0x43, 0xae, 0xb9, 0xfb, 0xe8,
0x43, 0x0e, 0x46, 0x0e, 0x4e, 0x20, 0xdd, 0xf3, 0x0b, 0x12, 0x20, 0xa8, 0xea, 0x9e, 0xc7, 0x52,
0x14, 0x24, 0x21, 0x41, 0x4e, 0xd3, 0xfd, 0xd5, 0xd7, 0xd5, 0xd5, 0x5d, 0xd5, 0xd5, 0xd5, 0x03,
0x0d, 0x19, 0xc6, 0xdd, 0x30, 0x92, 0x4a, 0xb2, 0x62, 0x78, 0xbc, 0x7e, 0xfb, 0xc4, 0x55, 0xa7,
0xf3, 0xe3, 0xae, 0x23, 0xfd, 0xdd, 0x13, 0x79, 0x22, 0x77, 0x49, 0x74, 0x3c, 0x9f, 0x51, 0x8f,
0x3a, 0xd4, 0xd2, 0x43, 0xac, 0x3f, 0x15, 0xa1, 0x38, 0x0e, 0xd9, 0xc7, 0x50, 0x75, 0x83, 0x70,
0xae, 0xe2, 0x4e, 0x61, 0xab, 0xb4, 0xdd, 0xdc, 0x6b, 0x74, 0xc3, 0xe3, 0xee, 0x08, 0x11, 0x6e,
0x04, 0x6c, 0x0b, 0xca, 0xe2, 0x5c, 0x38, 0x9d, 0xe2, 0x56, 0x61, 0xbb, 0xb9, 0x07, 0x48, 0x18,
0x9e, 0x0b, 0x67, 0x1c, 0x1e, 0xac, 0x70, 0x92, 0xb0, 0x4f, 0xa1, 0x1a, 0xcb, 0x79, 0xe4, 0x88,
0x4e, 0x89, 0x38, 0x2d, 0xe4, 0x4c, 0x08, 0x21, 0x96, 0x91, 0xa2, 0xa6, 0x99, 0xeb, 0x89, 0x4e,
0x39, 0xd3, 0x74, 0xd7, 0xf5, 0x34, 0x87, 0x24, 0xec, 0x13, 0xa8, 0x1c, 0xcf, 0x5d, 0x6f, 0xda,
0xa9, 0x10, 0xa5, 0x89, 0x94, 0x1e, 0x02, 0xc4, 0xd1, 0x32, 0xb6, 0x0d, 0xf5, 0xd0, 0xb3, 0xd5,
0x4c, 0x46, 0x7e, 0x07, 0xb2, 0x09, 0x8f, 0x0c, 0xc6, 0x53, 0x29, 0xbb, 0x03, 0x4d, 0x47, 0x06,
0xb1, 0x8a, 0x6c, 0x37, 0x50, 0x71, 0xa7, 0x49, 0xe4, 0xf7, 0x91, 0xfc, 0x44, 0x46, 0x67, 0x22,
0xea, 0x67, 0x42, 0x9e, 0x67, 0xf6, 0xca, 0x50, 0x94, 0xa1, 0xf5, 0xbb, 0x02, 0xd4, 0x13, 0xad,
0xcc, 0x82, 0xd6, 0x7e, 0xe4, 0x9c, 0xba, 0x4a, 0x38, 0x6a, 0x1e, 0x89, 0x4e, 0x61, 0xab, 0xb0,
0xdd, 0xe0, 0x4b, 0x18, 0x5b, 0x83, 0xe2, 0x78, 0x42, 0x1b, 0xd5, 0xe0, 0xc5, 0xf1, 0x84, 0x75,
0xa0, 0xf6, 0xd8, 0x8e, 0x5c, 0x3b, 0x50, 0xb4, 0x33, 0x0d, 0x9e, 0x74, 0xd9, 0x35, 0x68, 0x8c,
0x27, 0x8f, 0x45, 0x14, 0xbb, 0x32, 0xa0, 0xfd, 0x68, 0xf0, 0x0c, 0x60, 0x1b, 0x00, 0xe3, 0xc9,
0x5d, 0x61, 0xa3, 0xd2, 0xb8, 0x53, 0xd9, 0x2a, 0x6d, 0x37, 0x78, 0x0e, 0xb1, 0x7e, 0x0d, 0x15,
0xf2, 0x11, 0xfb, 0x0a, 0xaa, 0x53, 0xf7, 0x44, 0xc4, 0x4a, 0x9b, 0xd3, 0xdb, 0xfb, 0xf6, 0x87,
0xcd, 0x95, 0xbf, 0xfd, 0xb0, 0xb9, 0x93, 0x0b, 0x06, 0x19, 0x8a, 0xc0, 0x91, 0x81, 0xb2, 0xdd,
0x40, 0x44, 0xf1, 0xee, 0x89, 0xbc, 0xad, 0x87, 0x74, 0x07, 0xf4, 0xe1, 0x46, 0x03, 0xbb, 0x01,
0x15, 0x37, 0x98, 0x8a, 0x73, 0xb2, 0xbf, 0xd4, 0x7b, 0xcf, 0xa8, 0x6a, 0x8e, 0xe7, 0x2a, 0x9c,
0xab, 0x11, 0x8a, 0xb8, 0x66, 0x58, 0x7f, 0x28, 0x40, 0x55, 0xc7, 0x00, 0xbb, 0x06, 0x65, 0x5f,
0x28, 0x9b, 0xe6, 0x6f, 0xee, 0xd5, 0x71, 0x6f, 0x1f, 0x08, 0x65, 0x73, 0x42, 0x31, 0xbc, 0x7c,
0x39, 0xc7, 0xbd, 0x2f, 0x66, 0xe1, 0xf5, 0x00, 0x11, 0x6e, 0x04, 0xec, 0xa7, 0x50, 0x0b, 0x84,
0x7a, 0x2e, 0xa3, 0x33, 0xda, 0xa3, 0x35, 0xed, 0xf4, 0x43, 0xa1, 0x1e, 0xc8, 0xa9, 0xe0, 0x89,
0x8c, 0xdd, 0x82, 0x7a, 0x2c, 0x9c, 0x79, 0xe4, 0xaa, 0x05, 0xed, 0xd7, 0xda, 0x5e, 0x9b, 0xa2,
0xcc, 0x60, 0x44, 0x4e, 0x19, 0xd6, 0x6f, 0x8a, 0x50, 0x46, 0x33, 0x18, 0x83, 0xb2, 0x1d, 0x9d,
0xe8, 0xe8, 0x6e, 0x70, 0x6a, 0xb3, 0x36, 0x94, 0x44, 0xf0, 0x8c, 0x2c, 0x6a, 0x70, 0x6c, 0x22,
0xe2, 0x3c, 0x9f, 0x1a, 0x1f, 0x61, 0x13, 0xc7, 0xcd, 0x63, 0x11, 0x19, 0xd7, 0x50, 0x9b, 0xdd,
0x80, 0x46, 0x18, 0xc9, 0xf3, 0xc5, 0x53, 0x1c, 0x5d, 0xc9, 0x05, 0x1e, 0x82, 0xc3, 0xe0, 0x19,
0xaf, 0x87, 0xa6, 0xc5, 0x76, 0x00, 0xc4, 0xb9, 0x8a, 0xec, 0x03, 0x19, 0xab, 0xb8, 0x53, 0xa5,
0xb5, 0x53, 0xbc, 0x23, 0x30, 0x3a, 0xe2, 0x39, 0x29, 0x5b, 0x87, 0xfa, 0xa9, 0x8c, 0x55, 0x60,
0xfb, 0xa2, 0x53, 0xa3, 0xe9, 0xd2, 0x3e, 0x06, 0x50, 0x7c, 0xea, 0x4f, 0xdc, 0x5f, 0x89, 0x4e,
0x1d, 0xbd, 0xc2, 0x93, 0x2e, 0xb3, 0xa0, 0x3a, 0xf7, 0x5c, 0xdf, 0x55, 0x9d, 0x46, 0xa6, 0xfd,
0x11, 0x21, 0xdc, 0x48, 0xac, 0x5b, 0x50, 0xd5, 0xf3, 0xe1, 0x72, 0xb0, 0x65, 0x82, 0x96, 0xda,
0x18, 0xac, 0xa3, 0xa3, 0x24, 0x58, 0x47, 0x47, 0xd6, 0x00, 0xaa, 0x7a, 0x3c, 0xb2, 0x0f, 0xd1,
0x1a, 0xc3, 0xc6, 0x36, 0x62, 0x13, 0x39, 0x53, 0x3a, 0x38, 0x38, 0xb5, 0x49, 0xab, 0x1d, 0xe9,
0x7d, 0x2b, 0x71, 0x6a, 0x5b, 0xff, 0x2c, 0x42, 0x85, 0x1c, 0xcc, 0xb6, 0x31, 0x9e, 0xc2, 0xb9,
0x9e, 0xb4, 0xd4, 0x63, 0x26, 0x9e, 0x80, 0x22, 0x37, 0x0d, 0x27, 0x8c, 0xe2, 0x75, 0xf4, 0xad,
0x27, 0x1c, 0x25, 0x23, 0x63, 0x4f, 0xda, 0xc7, 0x39, 0xa6, 0x18, 0xdf, 0xda, 0x37, 0xd4, 0x66,
0x37, 0xa1, 0x2a, 0x29, 0x28, 0xc9, 0x3d, 0xaf, 0x09, 0x55, 0x43, 0x41, 0xe5, 0x91, 0xb0, 0xa7,
0x32, 0xf0, 0x16, 0xe4, 0xb4, 0x3a, 0x4f, 0xfb, 0xec, 0x26, 0x34, 0x28, 0x0a, 0x1f, 0x2e, 0x42,
0xd1, 0xa9, 0x52, 0x54, 0xad, 0xa6, 0x11, 0x8a, 0x20, 0xcf, 0xe4, 0x98, 0x76, 0x1c, 0xdb, 0x39,
0x15, 0xe3, 0x50, 0x75, 0xae, 0x66, 0xde, 0xef, 0x1b, 0x8c, 0xa7, 0x52, 0x54, 0x1b, 0x0b, 0x27,
0x12, 0x0a, 0xa9, 0xef, 0x13, 0x75, 0xd5, 0x04, 0xab, 0x06, 0x79, 0x26, 0x47, 0x47, 0x4e, 0x26,
0x07, 0xc8, 0xfc, 0x20, 0x4b, 0x8b, 0x1a, 0xe1, 0x46, 0xa2, 0xd7, 0x10, 0xcf, 0x3d, 0x35, 0x1a,
0x74, 0x3e, 0xd4, 0x1b, 0x94, 0xf4, 0xad, 0x11, 0xd4, 0x13, 0x13, 0xc8, 0xa5, 0x03, 0xe3, 0xb6,
0xe2, 0x68, 0xc0, 0x6e, 0x63, 0xf8, 0xd8, 0x91, 0x1b, 0x9c, 0xd0, 0xbe, 0xae, 0xed, 0xbd, 0x97,
0x5a, 0x3c, 0xd1, 0x38, 0xce, 0x92, 0x70, 0x2c, 0x09, 0x8d, 0xd4, 0xc4, 0x57, 0x74, 0xb5, 0xa1,
0x34, 0x77, 0xa7, 0xa4, 0x67, 0x95, 0x63, 0x13, 0x91, 0x13, 0x57, 0x7b, 0x7f, 0x95, 0x63, 0x13,
0x9d, 0xe5, 0xcb, 0xa9, 0x4e, 0xf0, 0xab, 0x9c, 0xda, 0x68, 0xbb, 0x0c, 0x95, 0x2b, 0x03, 0xdb,
0x4b, 0xf6, 0x3f, 0xe9, 0x5b, 0x5e, 0xb2, 0xf6, 0xff, 0xcb, 0x6c, 0xbf, 0x2d, 0x40, 0x3d, 0xb9,
0x95, 0x30, 0xc5, 0xba, 0x53, 0x11, 0x28, 0x77, 0xe6, 0x8a, 0xc8, 0x4c, 0x9c, 0x43, 0xd8, 0x6d,
0xa8, 0xd8, 0x4a, 0x45, 0x49, 0xe2, 0xfa, 0x30, 0x7f, 0xa5, 0x75, 0xf7, 0x51, 0x32, 0x0c, 0x54,
0xb4, 0xe0, 0x9a, 0xb5, 0xfe, 0x05, 0x40, 0x06, 0xa2, 0xad, 0x67, 0x62, 0x61, 0xb4, 0x62, 0x93,
0x5d, 0x85, 0xca, 0x33, 0xdb, 0x9b, 0x0b, 0x13, 0xdf, 0xba, 0xf3, 0x65, 0xf1, 0x8b, 0x82, 0xf5,
0x97, 0x22, 0xd4, 0xcc, 0x15, 0xc7, 0x6e, 0x41, 0x8d, 0xae, 0x38, 0x63, 0xd1, 0xe5, 0x87, 0x26,
0xa1, 0xb0, 0xdd, 0xf4, 0xee, 0xce, 0xd9, 0x68, 0x54, 0xe9, 0x3b, 0xdc, 0xd8, 0x98, 0xdd, 0xe4,
0xa5, 0xa9, 0x98, 0x99, 0x4b, 0x7a, 0x0d, 0xd9, 0x03, 0x31, 0x73, 0x03, 0x17, 0xf7, 0x87, 0xa3,
0x88, 0xdd, 0x4a, 0x56, 0x5d, 0x26, 0x8d, 0x1f, 0xe4, 0x35, 0xbe, 0xba, 0xe8, 0x11, 0x34, 0x73,
0xd3, 0x5c, 0xb2, 0xea, 0xeb, 0xf9, 0x55, 0x9b, 0x29, 0x49, 0x9d, 0xae, 0x30, 0xb2, 0x5d, 0xf8,
0x2f, 0xf6, 0xef, 0x73, 0x80, 0x4c, 0xe5, 0xdb, 0x27, 0x1d, 0xeb, 0xeb, 0x12, 0xc0, 0x38, 0xc4,
0x4b, 0x62, 0x6a, 0xd3, 0x4d, 0xd5, 0x72, 0x4f, 0x02, 0x19, 0x89, 0xa7, 0x74, 0x8c, 0x69, 0x7c,
0x9d, 0x37, 0x35, 0x46, 0x27, 0x86, 0xed, 0x43, 0x73, 0x2a, 0x62, 0x27, 0x72, 0x29, 0xa0, 0xcc,
0xa6, 0x6f, 0xe2, 0x9a, 0x32, 0x3d, 0xdd, 0x41, 0xc6, 0xd0, 0x7b, 0x95, 0x1f, 0xc3, 0xf6, 0xa0,
0x25, 0xce, 0x43, 0x19, 0x29, 0x33, 0x8b, 0xae, 0x84, 0xae, 0xe8, 0x9a, 0x0a, 0x71, 0x9a, 0x89,
0x37, 0x45, 0xd6, 0x61, 0x36, 0x94, 0x1d, 0x3b, 0xd4, 0x65, 0x40, 0x73, 0xaf, 0x73, 0x61, 0xbe,
0xbe, 0x1d, 0xea, 0x4d, 0xeb, 0x7d, 0x86, 0x6b, 0xfd, 0xfa, 0xef, 0x9b, 0x37, 0x73, 0x77, 0xbf,
0x2f, 0x8f, 0x17, 0xbb, 0x14, 0x2f, 0x67, 0xae, 0xda, 0x9d, 0x2b, 0xd7, 0xdb, 0xb5, 0x43, 0x17,
0xd5, 0xe1, 0xc0, 0xd1, 0x80, 0x93, 0xea, 0xf5, 0x9f, 0x43, 0xfb, 0xa2, 0xdd, 0xef, 0xe2, 0x83,
0xf5, 0x3b, 0xd0, 0x48, 0xed, 0x78, 0xd3, 0xc0, 0x7a, 0xde, 0x79, 0x7f, 0x2e, 0x40, 0x55, 0x9f,
0x2a, 0x76, 0x07, 0x1a, 0x9e, 0x74, 0x6c, 0x34, 0x20, 0x29, 0x46, 0x3f, 0xca, 0x0e, 0x5d, 0xf7,
0x7e, 0x22, 0xd3, 0xbb, 0x9a, 0x71, 0x31, 0xc8, 0xdc, 0x60, 0x26, 0x93, 0x53, 0xb0, 0x96, 0x0d,
0x1a, 0x05, 0x33, 0xc9, 0xb5, 0x70, 0xfd, 0x1e, 0xac, 0x2d, 0xab, 0xb8, 0xc4, 0xce, 0x4f, 0x96,
0xc3, 0x95, 0x72, 0x76, 0x3a, 0x28, 0x6f, 0xf6, 0x1d, 0x68, 0xa4, 0x38, 0xdb, 0x79, 0xd5, 0xf0,
0x56, 0x7e, 0x64, 0xce, 0x56, 0xcb, 0x03, 0xc8, 0x4c, 0xc3, 0x64, 0x85, 0x55, 0x6f, 0x90, 0xdd,
0xb5, 0x69, 0x9f, 0xee, 0x3d, 0x5b, 0xd9, 0x64, 0x4a, 0x8b, 0x53, 0x9b, 0x75, 0x01, 0xa6, 0xe9,
0x81, 0x7d, 0xcd, 0x31, 0xce, 0x31, 0xac, 0x31, 0xd4, 0x13, 0x23, 0xd8, 0x16, 0x34, 0x63, 0x33,
0x33, 0xd6, 0x78, 0x38, 0x5d, 0x85, 0xe7, 0x21, 0xac, 0xd5, 0x22, 0x3b, 0x38, 0x11, 0x4b, 0xb5,
0x1a, 0x47, 0x84, 0x1b, 0x81, 0xf5, 0x04, 0x2a, 0x04, 0xe0, 0x31, 0x8b, 0x95, 0x1d, 0x29, 0x53,
0xf6, 0xe9, 0x32, 0x48, 0xc6, 0x34, 0x6d, 0xaf, 0x8c, 0x81, 0xc8, 0x35, 0x81, 0x5d, 0xc7, 0x62,
0x6b, 0x6a, 0x76, 0xf4, 0x32, 0x1e, 0x8a, 0xad, 0x9f, 0x41, 0x3d, 0x81, 0x71, 0xe5, 0xf7, 0xdd,
0x40, 0x18, 0x13, 0xa9, 0x8d, 0xe5, 0x72, 0xff, 0xd4, 0x8e, 0x6c, 0x47, 0x09, 0x5d, 0x22, 0x54,
0x78, 0x06, 0x58, 0x9f, 0x40, 0x33, 0x77, 0x7a, 0x30, 0xdc, 0x1e, 0x93, 0x1b, 0xf5, 0x19, 0xd6,
0x1d, 0xeb, 0x8f, 0x58, 0xcc, 0x27, 0xf5, 0xd9, 0x4f, 0x00, 0x4e, 0x95, 0x0a, 0x9f, 0x52, 0xc1,
0x66, 0xf6, 0xbe, 0x81, 0x08, 0x31, 0xd8, 0x26, 0x34, 0xb1, 0x13, 0x1b, 0xb9, 0x8e, 0x77, 0x1a,
0x11, 0x6b, 0xc2, 0x8f, 0xa1, 0x31, 0x4b, 0x87, 0x97, 0x8c, 0xeb, 0x92, 0xd1, 0x1f, 0x41, 0x3d,
0x90, 0x46, 0xa6, 0xeb, 0xc7, 0x5a, 0x20, 0xd3, 0x71, 0xb6, 0xe7, 0x19, 0x59, 0x45, 0x8f, 0xb3,
0x3d, 0x8f, 0x84, 0xd6, 0x4d, 0xf8, 0xd1, 0x2b, 0xcf, 0x12, 0xf6, 0x01, 0x54, 0x67, 0xae, 0xa7,
0xe8, 0x46, 0xc0, 0x7a, 0xd5, 0xf4, 0xac, 0x7f, 0x17, 0x00, 0x32, 0xb7, 0x63, 0x30, 0x63, 0x6a,
0x47, 0x4e, 0x4b, 0xa7, 0x72, 0x0f, 0xea, 0xbe, 0x49, 0x12, 0xc6, 0xa1, 0xd7, 0x96, 0x43, 0xa5,
0x9b, 0xe4, 0x10, 0x9d, 0x3e, 0xf6, 0x4c, 0xfa, 0x78, 0x97, 0xa7, 0x43, 0x3a, 0x03, 0x55, 0x31,
0xf9, 0x27, 0x20, 0x64, 0xa7, 0x90, 0x1b, 0xc9, 0xfa, 0x3d, 0x58, 0x5d, 0x9a, 0xf2, 0x2d, 0x2f,
0x8c, 0x2c, 0xd9, 0xe5, 0x8f, 0xe0, 0x1e, 0x54, 0xf5, 0xdb, 0x91, 0x6d, 0x43, 0xcd, 0x76, 0xf4,
0xe9, 0xcb, 0x65, 0x00, 0x14, 0xee, 0x13, 0xcc, 0x13, 0xb1, 0xf5, 0xd7, 0x22, 0x40, 0x86, 0xbf,
0x43, 0x81, 0xfa, 0x25, 0xac, 0xc5, 0xc2, 0x91, 0xc1, 0xd4, 0x8e, 0x16, 0x24, 0x35, 0x6f, 0xa4,
0xcb, 0x86, 0x5c, 0x60, 0xe6, 0x8a, 0xd5, 0xd2, 0x9b, 0x8b, 0xd5, 0x6d, 0x28, 0x3b, 0x32, 0x5c,
0x98, 0x7b, 0x81, 0x2d, 0x2f, 0xa4, 0x2f, 0xc3, 0x05, 0xbe, 0x94, 0x91, 0xc1, 0xba, 0x50, 0xf5,
0xcf, 0xe8, 0x35, 0xad, 0x5f, 0x22, 0x57, 0x97, 0xb9, 0x0f, 0xce, 0xb0, 0x8d, 0x6f, 0x6f, 0xcd,
0x62, 0x37, 0xa1, 0xe2, 0x9f, 0x4d, 0xdd, 0x88, 0xca, 0xdc, 0xa6, 0x2e, 0x04, 0xf3, 0xf4, 0x81,
0x1b, 0xe1, 0x0b, 0x9b, 0x38, 0xcc, 0x82, 0x62, 0xe4, 0xd3, 0x63, 0xa4, 0xa9, 0x9f, 0x59, 0xb9,
0xdd, 0xf4, 0x0f, 0x56, 0x78, 0x31, 0xf2, 0x7b, 0x75, 0xa8, 0xea, 0x7d, 0xb5, 0xfe, 0x55, 0x82,
0xb5, 0x65, 0x2b, 0xd1, 0xb3, 0x71, 0xe4, 0x24, 0x9e, 0x8d, 0x23, 0x27, 0xad, 0xe3, 0x8b, 0xb9,
0x3a, 0xde, 0x82, 0x8a, 0x7c, 0x1e, 0x88, 0x28, 0xff, 0xdb, 0xa0, 0x7f, 0x2a, 0x9f, 0x07, 0x58,
0x95, 0x6a, 0xd1, 0x52, 0x91, 0x57, 0x31, 0x45, 0xde, 0x75, 0x58, 0x9d, 0x49, 0xcf, 0x93, 0xcf,
0x27, 0x0b, 0xdf, 0x73, 0x83, 0x33, 0x53, 0xe9, 0x2d, 0x83, 0x6c, 0x1b, 0xae, 0x4c, 0xdd, 0x08,
0xcd, 0xe9, 0xcb, 0x40, 0x89, 0x80, 0x1e, 0x62, 0xc8, 0xbb, 0x08, 0xb3, 0xaf, 0x60, 0xcb, 0x56,
0x4a, 0xf8, 0xa1, 0x7a, 0x14, 0x84, 0xb6, 0x73, 0x36, 0x90, 0x0e, 0x9d, 0x42, 0x3f, 0xb4, 0x95,
0x7b, 0xec, 0x7a, 0xf8, 0xe6, 0xac, 0xd1, 0xd0, 0x37, 0xf2, 0xd8, 0xa7, 0xb0, 0xe6, 0x44, 0xc2,
0x56, 0x62, 0x20, 0x62, 0x75, 0x64, 0xab, 0x53, 0x7a, 0xb8, 0xd5, 0xf9, 0x05, 0x14, 0xd7, 0x60,
0xa3, 0xb5, 0x4f, 0x5c, 0x6f, 0xea, 0xe0, 0x23, 0xaa, 0xa1, 0xd7, 0xb0, 0x04, 0xb2, 0x2e, 0x30,
0x02, 0x86, 0x7e, 0xa8, 0x16, 0x29, 0x15, 0x88, 0x7a, 0x89, 0x04, 0xf3, 0xa4, 0x72, 0x7d, 0x11,
0x2b, 0xdb, 0x0f, 0xe9, 0x77, 0x47, 0x89, 0x67, 0x00, 0xbb, 0x01, 0x6d, 0x37, 0x70, 0xbc, 0xf9,
0x54, 0x3c, 0x0d, 0x71, 0x21, 0x51, 0x10, 0x77, 0x5a, 0x94, 0x55, 0xae, 0x18, 0xfc, 0xc8, 0xc0,
0x48, 0x15, 0xe7, 0x17, 0xa8, 0xab, 0x9a, 0x6a, 0xf0, 0x84, 0x6a, 0x7d, 0x53, 0x80, 0xf6, 0xc5,
0xc0, 0x43, 0xb7, 0x85, 0xb8, 0x78, 0xf3, 0x84, 0xc4, 0x76, 0xea, 0xca, 0x62, 0xce, 0x95, 0xc9,
0x35, 0x57, 0xca, 0x5d, 0x73, 0x69, 0x58, 0x94, 0x5f, 0x1f, 0x16, 0x4b, 0x0b, 0xad, 0x5c, 0x58,
0xa8, 0xf5, 0xfb, 0x02, 0x5c, 0xb9, 0x10, 0xdc, 0x6f, 0x6d, 0xd1, 0x16, 0x34, 0x7d, 0xfb, 0x4c,
0x1c, 0xd9, 0x11, 0x85, 0x4c, 0x49, 0xd7, 0x81, 0x39, 0xe8, 0x7f, 0x60, 0x5f, 0x00, 0xad, 0xfc,
0x89, 0xba, 0xd4, 0xb6, 0x24, 0x40, 0x0e, 0xa5, 0xba, 0x2b, 0xe7, 0xe6, 0x0a, 0x4d, 0x02, 0x24,
0x01, 0x5f, 0x0d, 0xa3, 0xd2, 0x25, 0x61, 0x64, 0x1d, 0x42, 0x3d, 0x31, 0x90, 0x6d, 0x9a, 0x3f,
0x1b, 0x85, 0xec, 0x0f, 0xdb, 0xa3, 0x58, 0x44, 0x68, 0xbb, 0xfe, 0xcd, 0xf1, 0x31, 0x54, 0x4e,
0x22, 0x39, 0x0f, 0x4d, 0x0e, 0x5e, 0x62, 0x68, 0x89, 0x35, 0x81, 0x9a, 0x41, 0xd8, 0x0e, 0x54,
0x8f, 0x17, 0xe9, 0xdf, 0x02, 0x93, 0x2e, 0xb0, 0x3f, 0x35, 0x0c, 0xcc, 0x41, 0x9a, 0xc1, 0xae,
0x42, 0xf9, 0x78, 0x31, 0x1a, 0xe8, 0x57, 0x1d, 0x66, 0x32, 0xec, 0xf5, 0xaa, 0xda, 0x20, 0xeb,
0x3e, 0xb4, 0xf2, 0xe3, 0x70, 0x53, 0x72, 0x95, 0x11, 0xb5, 0xb3, 0x94, 0x5d, 0x7c, 0x43, 0xca,
0xde, 0xd9, 0x86, 0x9a, 0xf9, 0x87, 0xc4, 0x1a, 0x50, 0x79, 0x74, 0x38, 0x19, 0x3e, 0x6c, 0xaf,
0xb0, 0x3a, 0x94, 0x0f, 0xc6, 0x93, 0x87, 0xed, 0x02, 0xb6, 0x0e, 0xc7, 0x87, 0xc3, 0x76, 0x71,
0xe7, 0x06, 0xb4, 0xf2, 0x7f, 0x91, 0x58, 0x13, 0x6a, 0x93, 0xfd, 0xc3, 0x41, 0x6f, 0xfc, 0xcb,
0xf6, 0x0a, 0x6b, 0x41, 0x7d, 0x74, 0x38, 0x19, 0xf6, 0x1f, 0xf1, 0x61, 0xbb, 0xb0, 0xf3, 0x0b,
0x68, 0xa4, 0xbf, 0x06, 0x50, 0x43, 0x6f, 0x74, 0x38, 0x68, 0xaf, 0x30, 0x80, 0xea, 0x64, 0xd8,
0xe7, 0x43, 0xd4, 0x5b, 0x83, 0xd2, 0x64, 0x72, 0xd0, 0x2e, 0xe2, 0xac, 0xfd, 0xfd, 0xfe, 0xc1,
0xb0, 0x5d, 0xc2, 0xe6, 0xc3, 0x07, 0x47, 0x77, 0x27, 0xed, 0xf2, 0xce, 0xe7, 0x70, 0xe5, 0xc2,
0xf3, 0x9b, 0x46, 0x1f, 0xec, 0xf3, 0x21, 0x6a, 0x6a, 0x42, 0xed, 0x88, 0x8f, 0x1e, 0xef, 0x3f,
0x1c, 0xb6, 0x0b, 0x28, 0xb8, 0x3f, 0xee, 0xdf, 0x1b, 0x0e, 0xda, 0xc5, 0xde, 0xb5, 0x6f, 0x5f,
0x6c, 0x14, 0xbe, 0x7b, 0xb1, 0x51, 0xf8, 0xfe, 0xc5, 0x46, 0xe1, 0x1f, 0x2f, 0x36, 0x0a, 0xdf,
0xbc, 0xdc, 0x58, 0xf9, 0xee, 0xe5, 0xc6, 0xca, 0xf7, 0x2f, 0x37, 0x56, 0x8e, 0xab, 0xf4, 0x4f,
0xf7, 0xb3, 0xff, 0x04, 0x00, 0x00, 0xff, 0xff, 0x4d, 0x50, 0xda, 0x43, 0x13, 0x16, 0x00, 0x00,
// 2335 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0xcd, 0x6e, 0x1b, 0xc9,
0x11, 0x16, 0xff, 0xc9, 0x22, 0x25, 0x33, 0xbd, 0x5e, 0x2f, 0x57, 0x71, 0x24, 0xed, 0xd8, 0x59,
0xc8, 0xb2, 0x4d, 0x01, 0x5a, 0x60, 0xbd, 0x58, 0x04, 0x41, 0xc4, 0x1f, 0x43, 0x5c, 0xdb, 0xa2,
0xd0, 0x94, 0xed, 0xdc, 0x8c, 0xd1, 0xb0, 0x49, 0x0d, 0x34, 0x9c, 0x1e, 0xcc, 0x34, 0x6d, 0x31,
0x87, 0x1c, 0xf6, 0x09, 0x16, 0x08, 0x10, 0xe4, 0x92, 0x04, 0x79, 0x87, 0x5c, 0x73, 0xdf, 0xe3,
0x1e, 0x72, 0x58, 0xe4, 0xb0, 0x09, 0xec, 0x53, 0xde, 0x21, 0x01, 0x82, 0xaa, 0xee, 0xf9, 0xa1,
0x2c, 0xc3, 0x36, 0x12, 0xe4, 0x34, 0xd5, 0x5f, 0x7d, 0x5d, 0x5d, 0xdd, 0x55, 0xdd, 0x5d, 0x3d,
0x50, 0x93, 0x41, 0xd4, 0x0e, 0x42, 0xa9, 0x24, 0xcb, 0x07, 0x27, 0xeb, 0x77, 0xa7, 0xae, 0x3a,
0x9d, 0x9f, 0xb4, 0x1d, 0x39, 0xdb, 0x9d, 0xca, 0xa9, 0xdc, 0x25, 0xd5, 0xc9, 0x7c, 0x42, 0x2d,
0x6a, 0x90, 0xa4, 0xbb, 0x58, 0x7f, 0xca, 0x43, 0x7e, 0x18, 0xb0, 0x4f, 0xa0, 0xec, 0xfa, 0xc1,
0x5c, 0x45, 0xad, 0xdc, 0x56, 0x61, 0xbb, 0xbe, 0x57, 0x6b, 0x07, 0x27, 0xed, 0x01, 0x22, 0xdc,
0x28, 0xd8, 0x16, 0x14, 0xc5, 0xb9, 0x70, 0x5a, 0xf9, 0xad, 0xdc, 0x76, 0x7d, 0x0f, 0x90, 0xd0,
0x3f, 0x17, 0xce, 0x30, 0x38, 0x58, 0xe1, 0xa4, 0x61, 0x9f, 0x42, 0x39, 0x92, 0xf3, 0xd0, 0x11,
0xad, 0x02, 0x71, 0x1a, 0xc8, 0x19, 0x11, 0x42, 0x2c, 0xa3, 0x45, 0x4b, 0x13, 0xd7, 0x13, 0xad,
0x62, 0x6a, 0xe9, 0xbe, 0xeb, 0x69, 0x0e, 0x69, 0xd8, 0x0d, 0x28, 0x9d, 0xcc, 0x5d, 0x6f, 0xdc,
0x2a, 0x11, 0xa5, 0x8e, 0x94, 0x0e, 0x02, 0xc4, 0xd1, 0x3a, 0xb6, 0x0d, 0xd5, 0xc0, 0xb3, 0xd5,
0x44, 0x86, 0xb3, 0x16, 0xa4, 0x03, 0x1e, 0x19, 0x8c, 0x27, 0x5a, 0x76, 0x0f, 0xea, 0x8e, 0xf4,
0x23, 0x15, 0xda, 0xae, 0xaf, 0xa2, 0x56, 0x9d, 0xc8, 0x1f, 0x22, 0xf9, 0xa9, 0x0c, 0xcf, 0x44,
0xd8, 0x4d, 0x95, 0x3c, 0xcb, 0xec, 0x14, 0x21, 0x2f, 0x03, 0xeb, 0xb7, 0x39, 0xa8, 0xc6, 0x56,
0x99, 0x05, 0x8d, 0xfd, 0xd0, 0x39, 0x75, 0x95, 0x70, 0xd4, 0x3c, 0x14, 0xad, 0xdc, 0x56, 0x6e,
0xbb, 0xc6, 0x97, 0x30, 0xb6, 0x06, 0xf9, 0xe1, 0x88, 0x16, 0xaa, 0xc6, 0xf3, 0xc3, 0x11, 0x6b,
0x41, 0xe5, 0x89, 0x1d, 0xba, 0xb6, 0xaf, 0x68, 0x65, 0x6a, 0x3c, 0x6e, 0xb2, 0xeb, 0x50, 0x1b,
0x8e, 0x9e, 0x88, 0x30, 0x72, 0xa5, 0x4f, 0xeb, 0x51, 0xe3, 0x29, 0xc0, 0x36, 0x00, 0x86, 0xa3,
0xfb, 0xc2, 0x46, 0xa3, 0x51, 0xab, 0xb4, 0x55, 0xd8, 0xae, 0xf1, 0x0c, 0x62, 0xfd, 0x1a, 0x4a,
0x14, 0x23, 0xf6, 0x15, 0x94, 0xc7, 0xee, 0x54, 0x44, 0x4a, 0xbb, 0xd3, 0xd9, 0xfb, 0xf6, 0x87,
0xcd, 0x95, 0xbf, 0xfd, 0xb0, 0xb9, 0x93, 0x49, 0x06, 0x19, 0x08, 0xdf, 0x91, 0xbe, 0xb2, 0x5d,
0x5f, 0x84, 0xd1, 0xee, 0x54, 0xde, 0xd5, 0x5d, 0xda, 0x3d, 0xfa, 0x70, 0x63, 0x81, 0xdd, 0x82,
0x92, 0xeb, 0x8f, 0xc5, 0x39, 0xf9, 0x5f, 0xe8, 0x7c, 0x60, 0x4c, 0xd5, 0x87, 0x73, 0x15, 0xcc,
0xd5, 0x00, 0x55, 0x5c, 0x33, 0xac, 0x3f, 0xe4, 0xa0, 0xac, 0x73, 0x80, 0x5d, 0x87, 0xe2, 0x4c,
0x28, 0x9b, 0xc6, 0xaf, 0xef, 0x55, 0x71, 0x6d, 0x1f, 0x09, 0x65, 0x73, 0x42, 0x31, 0xbd, 0x66,
0x72, 0x8e, 0x6b, 0x9f, 0x4f, 0xd3, 0xeb, 0x11, 0x22, 0xdc, 0x28, 0xd8, 0x4f, 0xa1, 0xe2, 0x0b,
0xf5, 0x42, 0x86, 0x67, 0xb4, 0x46, 0x6b, 0x3a, 0xe8, 0x87, 0x42, 0x3d, 0x92, 0x63, 0xc1, 0x63,
0x1d, 0xbb, 0x03, 0xd5, 0x48, 0x38, 0xf3, 0xd0, 0x55, 0x0b, 0x5a, 0xaf, 0xb5, 0xbd, 0x26, 0x65,
0x99, 0xc1, 0x88, 0x9c, 0x30, 0xac, 0x7f, 0xe6, 0xa0, 0x88, 0x6e, 0x30, 0x06, 0x45, 0x3b, 0x9c,
0xea, 0xec, 0xae, 0x71, 0x92, 0x59, 0x13, 0x0a, 0xc2, 0x7f, 0x4e, 0x1e, 0xd5, 0x38, 0x8a, 0x88,
0x38, 0x2f, 0xc6, 0x26, 0x46, 0x28, 0x62, 0xbf, 0x79, 0x24, 0x42, 0x13, 0x1a, 0x92, 0xd9, 0x2d,
0xa8, 0x05, 0xa1, 0x3c, 0x5f, 0x3c, 0xc3, 0xde, 0xa5, 0x4c, 0xe2, 0x21, 0xd8, 0xf7, 0x9f, 0xf3,
0x6a, 0x60, 0x24, 0xb6, 0x03, 0x20, 0xce, 0x55, 0x68, 0x1f, 0xc8, 0x48, 0x45, 0xad, 0x32, 0xcd,
0x9d, 0xf2, 0x1d, 0x81, 0xc1, 0x11, 0xcf, 0x68, 0xd9, 0x3a, 0x54, 0x4f, 0x65, 0xa4, 0x7c, 0x7b,
0x26, 0x5a, 0x15, 0x1a, 0x2e, 0x69, 0x33, 0x0b, 0xca, 0x73, 0xcf, 0x9d, 0xb9, 0xaa, 0x55, 0x4b,
0x6d, 0x3c, 0x26, 0x84, 0x1b, 0x8d, 0x75, 0x07, 0xca, 0xda, 0x2a, 0x3a, 0x8d, 0x92, 0x49, 0x4d,
0x92, 0x31, 0x25, 0x07, 0x47, 0x71, 0x4a, 0x0e, 0x8e, 0xac, 0x1e, 0x94, 0x75, 0x7f, 0x64, 0x1f,
0xe2, 0x98, 0x86, 0x8d, 0x32, 0x62, 0x23, 0x39, 0x51, 0x3a, 0x05, 0x38, 0xc9, 0x64, 0xd5, 0x0e,
0xf5, 0xea, 0x14, 0x38, 0xc9, 0xd6, 0xef, 0x0a, 0x50, 0xa2, 0x30, 0xb2, 0x6d, 0xcc, 0x9a, 0x60,
0xae, 0x07, 0x2d, 0x74, 0x98, 0xc9, 0x1a, 0xa0, 0xfc, 0x4c, 0x92, 0x06, 0x73, 0x75, 0x1d, 0x23,
0xe8, 0x09, 0x47, 0xc9, 0xd0, 0xf8, 0x93, 0xb4, 0x71, 0x8c, 0x31, 0x66, 0xb1, 0x8e, 0x00, 0xc9,
0xec, 0x36, 0x94, 0x25, 0xa5, 0x1e, 0x05, 0xe1, 0x0d, 0x09, 0x69, 0x28, 0x68, 0x3c, 0x14, 0xf6,
0x58, 0xfa, 0xde, 0x82, 0x42, 0x53, 0xe5, 0x49, 0x9b, 0xdd, 0x86, 0x1a, 0xe5, 0xda, 0xf1, 0x22,
0x10, 0xad, 0x32, 0xe5, 0xce, 0x6a, 0x92, 0x87, 0x08, 0xf2, 0x54, 0x8f, 0x87, 0xcb, 0xf1, 0x2c,
0x98, 0x44, 0xc3, 0x40, 0xb5, 0x3e, 0x48, 0x63, 0x1c, 0x63, 0x3c, 0xd1, 0x22, 0xd3, 0xb1, 0x9d,
0x53, 0x81, 0xcc, 0xab, 0x29, 0xb3, 0x6b, 0x30, 0x9e, 0x68, 0xd1, 0x81, 0x48, 0x38, 0xa1, 0x50,
0x48, 0xfd, 0x90, 0xa8, 0xab, 0x26, 0x79, 0x35, 0xc8, 0x53, 0x3d, 0x86, 0x7c, 0x34, 0x3a, 0x40,
0xe6, 0xb5, 0xf4, 0x98, 0xd4, 0x08, 0x37, 0x1a, 0x3d, 0xdb, 0x68, 0xee, 0xa9, 0x41, 0xaf, 0xf5,
0x91, 0x5e, 0xca, 0xb8, 0x6d, 0x6d, 0xa4, 0x13, 0xc0, 0x65, 0x8d, 0xdc, 0x5f, 0xe9, 0x10, 0x17,
0x38, 0xc9, 0xd6, 0x00, 0xaa, 0xb1, 0x8b, 0x94, 0x1c, 0x3d, 0x93, 0x00, 0xf9, 0x41, 0x8f, 0xdd,
0x85, 0x4a, 0x74, 0x6a, 0x87, 0xae, 0x3f, 0xa5, 0x08, 0xad, 0xed, 0x7d, 0x90, 0xcc, 0x68, 0xa4,
0x71, 0xf4, 0x22, 0xe6, 0x58, 0x12, 0x6a, 0xc9, 0x14, 0x5e, 0xb3, 0xd5, 0x84, 0xc2, 0xdc, 0x1d,
0x93, 0x9d, 0x55, 0x8e, 0x22, 0x22, 0x53, 0x57, 0xe7, 0xd1, 0x2a, 0x47, 0x11, 0xfd, 0x9b, 0xc9,
0xb1, 0xbe, 0x10, 0x56, 0x39, 0xc9, 0x38, 0x37, 0x19, 0x28, 0x57, 0xfa, 0xb6, 0x17, 0x47, 0x32,
0x6e, 0x5b, 0x5e, 0xbc, 0x36, 0xff, 0x97, 0xd1, 0x7e, 0x93, 0x83, 0x6a, 0x7c, 0x8b, 0xe1, 0x91,
0xec, 0x8e, 0x85, 0xaf, 0xdc, 0x89, 0x2b, 0x42, 0x33, 0x70, 0x06, 0x61, 0x77, 0xa1, 0x64, 0x2b,
0x15, 0xc6, 0x07, 0xdd, 0x47, 0xd9, 0x2b, 0xb0, 0xbd, 0x8f, 0x9a, 0xbe, 0xaf, 0xc2, 0x05, 0xd7,
0xac, 0xf5, 0x2f, 0x00, 0x52, 0x10, 0x7d, 0x3d, 0x13, 0x0b, 0x63, 0x15, 0x45, 0x76, 0x15, 0x4a,
0xcf, 0x6d, 0x6f, 0x2e, 0xcc, 0x4e, 0xd1, 0x8d, 0x2f, 0xf3, 0x5f, 0xe4, 0xac, 0xbf, 0xe4, 0xa1,
0x62, 0xae, 0x44, 0x76, 0x07, 0x2a, 0x74, 0x25, 0x1a, 0x8f, 0x2e, 0xdf, 0x7e, 0x31, 0x85, 0xed,
0x26, 0x77, 0x7d, 0xc6, 0x47, 0x63, 0x4a, 0xdf, 0xf9, 0xc6, 0xc7, 0xf4, 0xe6, 0x2f, 0x8c, 0xc5,
0xc4, 0x5c, 0xea, 0x6b, 0xc8, 0xee, 0x89, 0x89, 0xeb, 0xbb, 0xb8, 0x3e, 0x1c, 0x55, 0xec, 0x4e,
0x3c, 0xeb, 0x22, 0x59, 0xbc, 0x96, 0xb5, 0xf8, 0xfa, 0xa4, 0x07, 0x50, 0xcf, 0x0c, 0x73, 0xc9,
0xac, 0x6f, 0x66, 0x67, 0x6d, 0x86, 0x24, 0x73, 0xba, 0x22, 0x49, 0x57, 0xe1, 0xbf, 0x58, 0xbf,
0xcf, 0x01, 0x52, 0x93, 0xef, 0x7e, 0x7c, 0x59, 0x5f, 0x17, 0x00, 0x86, 0x01, 0x5e, 0x2a, 0x63,
0x9b, 0x6e, 0xb6, 0x86, 0x3b, 0xf5, 0x65, 0x28, 0x9e, 0xd1, 0x36, 0xa7, 0xfe, 0x55, 0x5e, 0xd7,
0x18, 0xed, 0x18, 0xb6, 0x0f, 0xf5, 0xb1, 0x88, 0x9c, 0xd0, 0xa5, 0x84, 0x32, 0x8b, 0xbe, 0x89,
0x73, 0x4a, 0xed, 0xb4, 0x7b, 0x29, 0x43, 0xaf, 0x55, 0xb6, 0x0f, 0xdb, 0x83, 0x86, 0x38, 0x0f,
0x64, 0xa8, 0xcc, 0x28, 0xba, 0x72, 0xba, 0xa2, 0x6b, 0x30, 0xc4, 0x69, 0x24, 0x5e, 0x17, 0x69,
0x83, 0xd9, 0x50, 0x74, 0xec, 0x40, 0x97, 0x0d, 0xf5, 0xbd, 0xd6, 0x85, 0xf1, 0xba, 0x76, 0xa0,
0x17, 0xad, 0xf3, 0x19, 0xce, 0xf5, 0xeb, 0xbf, 0x6f, 0xde, 0xce, 0xd4, 0x0a, 0x33, 0x79, 0xb2,
0xd8, 0xa5, 0x7c, 0x39, 0x73, 0xd5, 0xee, 0x5c, 0xb9, 0xde, 0xae, 0x1d, 0xb8, 0x68, 0x0e, 0x3b,
0x0e, 0x7a, 0x9c, 0x4c, 0xaf, 0xff, 0x1c, 0x9a, 0x17, 0xfd, 0x7e, 0x9f, 0x18, 0xac, 0xdf, 0x83,
0x5a, 0xe2, 0xc7, 0xdb, 0x3a, 0x56, 0xb3, 0xc1, 0xfb, 0x73, 0x0e, 0xca, 0x7a, 0x57, 0xb1, 0x7b,
0x50, 0xf3, 0xa4, 0x63, 0xa3, 0x03, 0x71, 0xf1, 0xfa, 0x71, 0xba, 0xe9, 0xda, 0x0f, 0x63, 0x9d,
0x5e, 0xd5, 0x94, 0x8b, 0x49, 0xe6, 0xfa, 0x13, 0x19, 0xef, 0x82, 0xb5, 0xb4, 0xd3, 0xc0, 0x9f,
0x48, 0xae, 0x95, 0xeb, 0x0f, 0x60, 0x6d, 0xd9, 0xc4, 0x25, 0x7e, 0xde, 0x58, 0x4e, 0x57, 0x3a,
0xd3, 0x93, 0x4e, 0x59, 0xb7, 0xef, 0x41, 0x2d, 0xc1, 0xd9, 0xce, 0xeb, 0x8e, 0x37, 0xb2, 0x3d,
0x33, 0xbe, 0x5a, 0x1e, 0x40, 0xea, 0x1a, 0x1e, 0x56, 0x58, 0x25, 0xfb, 0xe9, 0xad, 0x9d, 0xb4,
0xe9, 0x06, 0xb5, 0x95, 0x4d, 0xae, 0x34, 0x38, 0xc9, 0xac, 0x0d, 0x30, 0x4e, 0x36, 0xec, 0x1b,
0xb6, 0x71, 0x86, 0x61, 0x0d, 0xa1, 0x1a, 0x3b, 0xc1, 0xb6, 0xa0, 0x1e, 0x99, 0x91, 0xb1, 0x26,
0xc4, 0xe1, 0x4a, 0x3c, 0x0b, 0x61, 0x6d, 0x17, 0xda, 0xfe, 0x54, 0x2c, 0xd5, 0x76, 0x1c, 0x11,
0x6e, 0x14, 0xd6, 0x53, 0x28, 0x11, 0x80, 0xdb, 0x2c, 0x52, 0x76, 0xa8, 0x4c, 0x99, 0xa8, 0xcb,
0x26, 0x19, 0xd1, 0xb0, 0x9d, 0x22, 0x26, 0x22, 0xd7, 0x04, 0x76, 0x13, 0x8b, 0xb3, 0xb1, 0x59,
0xd1, 0xcb, 0x78, 0xa8, 0xb6, 0x7e, 0x06, 0xd5, 0x18, 0xc6, 0x99, 0x3f, 0x74, 0x7d, 0x61, 0x5c,
0x24, 0x19, 0xcb, 0xeb, 0xee, 0xa9, 0x1d, 0xda, 0x8e, 0x12, 0xba, 0xd8, 0x28, 0xf1, 0x14, 0xb0,
0x6e, 0x40, 0x3d, 0xb3, 0x7b, 0x30, 0xdd, 0x9e, 0x50, 0x18, 0xf5, 0x1e, 0xd6, 0x0d, 0xeb, 0x8f,
0x58, 0xfc, 0xc7, 0xf5, 0xdc, 0x4f, 0x00, 0x4e, 0x95, 0x0a, 0x9e, 0x51, 0x81, 0x67, 0xd6, 0xbe,
0x86, 0x08, 0x31, 0xd8, 0x26, 0xd4, 0xb1, 0x11, 0x19, 0xbd, 0xce, 0x77, 0xea, 0x11, 0x69, 0xc2,
0x8f, 0xa1, 0x36, 0x49, 0xba, 0x17, 0x4c, 0xe8, 0xe2, 0xde, 0x1f, 0x43, 0xd5, 0x97, 0x46, 0xa7,
0xeb, 0xcd, 0x8a, 0x2f, 0x93, 0x7e, 0xb6, 0xe7, 0x19, 0x5d, 0x49, 0xf7, 0xb3, 0x3d, 0x8f, 0x94,
0xd6, 0x6d, 0xf8, 0xd1, 0x6b, 0xcf, 0x18, 0x76, 0x0d, 0xca, 0x13, 0xd7, 0x53, 0x74, 0x23, 0x60,
0x7d, 0x6b, 0x5a, 0xd6, 0xbf, 0x73, 0x00, 0x69, 0xd8, 0x31, 0x99, 0xf1, 0x68, 0x47, 0x4e, 0x43,
0x1f, 0xe5, 0x1e, 0x54, 0x67, 0xe6, 0x90, 0x30, 0x01, 0xbd, 0xbe, 0x9c, 0x2a, 0xed, 0xf8, 0x0c,
0xd1, 0xc7, 0xc7, 0x9e, 0x39, 0x3e, 0xde, 0xe7, 0xa9, 0x91, 0x8c, 0x40, 0x55, 0x4e, 0xf6, 0xc9,
0x08, 0xe9, 0x2e, 0xe4, 0x46, 0xb3, 0xfe, 0x00, 0x56, 0x97, 0x86, 0x7c, 0xc7, 0x0b, 0x23, 0x3d,
0xec, 0xb2, 0x5b, 0x70, 0x0f, 0xca, 0xfa, 0xad, 0xc9, 0xb6, 0xa1, 0x62, 0x3b, 0x7a, 0xf7, 0x65,
0x4e, 0x00, 0x54, 0xee, 0x13, 0xcc, 0x63, 0xb5, 0xf5, 0xd7, 0x3c, 0x40, 0x8a, 0xbf, 0x47, 0xa9,
0xfb, 0x25, 0xac, 0x45, 0xc2, 0x91, 0xfe, 0xd8, 0x0e, 0x17, 0xa4, 0x35, 0x6f, 0xaa, 0xcb, 0xba,
0x5c, 0x60, 0x66, 0xca, 0xde, 0xc2, 0xdb, 0xcb, 0xde, 0x6d, 0x28, 0x3a, 0x32, 0x58, 0x98, 0x7b,
0x81, 0x2d, 0x4f, 0xa4, 0x2b, 0x83, 0x05, 0xbe, 0xac, 0x91, 0xc1, 0xda, 0x50, 0x9e, 0x9d, 0xd1,
0xeb, 0x5b, 0xbf, 0x5c, 0xae, 0x2e, 0x73, 0x1f, 0x9d, 0xa1, 0x8c, 0x6f, 0x75, 0xcd, 0x62, 0xb7,
0xa1, 0x34, 0x3b, 0x1b, 0xbb, 0x21, 0x15, 0xcc, 0x75, 0x5d, 0x08, 0x66, 0xe9, 0x3d, 0x37, 0xc4,
0x17, 0x39, 0x71, 0x98, 0x05, 0xf9, 0x70, 0x46, 0x8f, 0x97, 0xba, 0x7e, 0x96, 0x65, 0x56, 0x73,
0x76, 0xb0, 0xc2, 0xf3, 0xe1, 0xac, 0x53, 0x85, 0xb2, 0x5e, 0x57, 0xeb, 0x5f, 0x05, 0x58, 0x5b,
0xf6, 0x12, 0x23, 0x1b, 0x85, 0x4e, 0x1c, 0xd9, 0x28, 0x74, 0x92, 0x17, 0x41, 0x3e, 0xf3, 0x22,
0xb0, 0xa0, 0x24, 0x5f, 0xf8, 0x22, 0xcc, 0xfe, 0x66, 0xe8, 0x9e, 0xca, 0x17, 0x3e, 0x56, 0xa5,
0x5a, 0xb5, 0x54, 0xe4, 0x95, 0x4c, 0x91, 0x77, 0x13, 0x56, 0x27, 0xd2, 0xf3, 0xe4, 0x8b, 0xd1,
0x62, 0xe6, 0xb9, 0xfe, 0x99, 0xa9, 0xf4, 0x96, 0x41, 0xb6, 0x0d, 0x57, 0xc6, 0x6e, 0x88, 0xee,
0x74, 0xa5, 0xaf, 0x84, 0x4f, 0x0f, 0x37, 0xe4, 0x5d, 0x84, 0xd9, 0x57, 0xb0, 0x65, 0x2b, 0x25,
0x66, 0x81, 0x7a, 0xec, 0x07, 0xb6, 0x73, 0xd6, 0x93, 0x0e, 0xed, 0xc2, 0x59, 0x60, 0x2b, 0xf7,
0xc4, 0xf5, 0xf0, 0x8d, 0x5a, 0xa1, 0xae, 0x6f, 0xe5, 0xb1, 0x4f, 0x61, 0xcd, 0x09, 0x85, 0xad,
0x44, 0x4f, 0x44, 0xea, 0xc8, 0x56, 0xa7, 0xad, 0x2a, 0xf5, 0xbc, 0x80, 0xe2, 0x1c, 0x6c, 0xf4,
0xf6, 0xa9, 0xeb, 0x8d, 0x1d, 0x7c, 0x8e, 0xd5, 0xf4, 0x1c, 0x96, 0x40, 0xd6, 0x06, 0x46, 0x40,
0x7f, 0x16, 0xa8, 0x45, 0x42, 0x05, 0xa2, 0x5e, 0xa2, 0xc1, 0x73, 0x52, 0xb9, 0x33, 0x11, 0x29,
0x7b, 0x16, 0xd0, 0xef, 0x91, 0x02, 0x4f, 0x01, 0x76, 0x0b, 0x9a, 0xae, 0xef, 0x78, 0xf3, 0xb1,
0x78, 0x16, 0xe0, 0x44, 0x42, 0x3f, 0x6a, 0x35, 0xe8, 0x54, 0xb9, 0x62, 0xf0, 0x23, 0x03, 0x23,
0x55, 0x9c, 0x5f, 0xa0, 0xae, 0x6a, 0xaa, 0xc1, 0x63, 0xaa, 0xf5, 0x4d, 0x0e, 0x9a, 0x17, 0x13,
0x0f, 0xc3, 0x16, 0xe0, 0xe4, 0xcd, 0x63, 0x14, 0xe5, 0x24, 0x94, 0xf9, 0x4c, 0x28, 0xe3, 0x6b,
0xae, 0x90, 0xb9, 0xe6, 0x92, 0xb4, 0x28, 0xbe, 0x39, 0x2d, 0x96, 0x26, 0x5a, 0xba, 0x30, 0x51,
0xeb, 0xf7, 0x39, 0xb8, 0x72, 0x21, 0xb9, 0xdf, 0xd9, 0xa3, 0x2d, 0xa8, 0xcf, 0xec, 0x33, 0x71,
0x64, 0x87, 0x94, 0x32, 0x05, 0x5d, 0x07, 0x66, 0xa0, 0xff, 0x81, 0x7f, 0x3e, 0x34, 0xb2, 0x3b,
0xea, 0x52, 0xdf, 0xe2, 0x04, 0x39, 0x94, 0xea, 0xbe, 0x9c, 0x9b, 0x2b, 0x34, 0x4e, 0x90, 0x18,
0x7c, 0x3d, 0x8d, 0x0a, 0x97, 0xa4, 0x91, 0x75, 0x08, 0xd5, 0xd8, 0x41, 0xb6, 0x69, 0xfe, 0x84,
0xe4, 0xd2, 0x3f, 0x72, 0x8f, 0x23, 0x11, 0xa2, 0xef, 0xfa, 0xb7, 0xc8, 0x27, 0x50, 0x9a, 0x86,
0x72, 0x1e, 0x98, 0x33, 0x78, 0x89, 0xa1, 0x35, 0xd6, 0x08, 0x2a, 0x06, 0x61, 0x3b, 0x50, 0x3e,
0x59, 0x24, 0xff, 0x1d, 0xcc, 0x71, 0x81, 0xed, 0xb1, 0x61, 0xe0, 0x19, 0xa4, 0x19, 0xec, 0x2a,
0x14, 0x4f, 0x16, 0x83, 0x9e, 0x7e, 0xd5, 0xe1, 0x49, 0x86, 0xad, 0x4e, 0x59, 0x3b, 0x64, 0x3d,
0x84, 0x46, 0xb6, 0x1f, 0x2e, 0x4a, 0xa6, 0x32, 0x22, 0x39, 0x3d, 0xb2, 0xf3, 0x6f, 0x39, 0xb2,
0x77, 0xb6, 0xa1, 0x62, 0xfe, 0x39, 0xb1, 0x1a, 0x94, 0x1e, 0x1f, 0x8e, 0xfa, 0xc7, 0xcd, 0x15,
0x56, 0x85, 0xe2, 0xc1, 0x70, 0x74, 0xdc, 0xcc, 0xa1, 0x74, 0x38, 0x3c, 0xec, 0x37, 0xf3, 0x3b,
0xb7, 0xa0, 0x91, 0xfd, 0xeb, 0xc4, 0xea, 0x50, 0x19, 0xed, 0x1f, 0xf6, 0x3a, 0xc3, 0x5f, 0x36,
0x57, 0x58, 0x03, 0xaa, 0x83, 0xc3, 0x51, 0xbf, 0xfb, 0x98, 0xf7, 0x9b, 0xb9, 0x9d, 0x5f, 0x40,
0x2d, 0xf9, 0xc9, 0x80, 0x16, 0x3a, 0x83, 0xc3, 0x5e, 0x73, 0x85, 0x01, 0x94, 0x47, 0xfd, 0x2e,
0xef, 0xa3, 0xdd, 0x0a, 0x14, 0x46, 0xa3, 0x83, 0x66, 0x1e, 0x47, 0xed, 0xee, 0x77, 0x0f, 0xfa,
0xcd, 0x02, 0x8a, 0xc7, 0x8f, 0x8e, 0xee, 0x8f, 0x9a, 0xc5, 0x9d, 0xcf, 0xe1, 0xca, 0x85, 0xe7,
0x37, 0xf5, 0x3e, 0xd8, 0xe7, 0x7d, 0xb4, 0x54, 0x87, 0xca, 0x11, 0x1f, 0x3c, 0xd9, 0x3f, 0xee,
0x37, 0x73, 0xa8, 0x78, 0x38, 0xec, 0x3e, 0xe8, 0xf7, 0x9a, 0xf9, 0xce, 0xf5, 0x6f, 0x5f, 0x6e,
0xe4, 0xbe, 0x7b, 0xb9, 0x91, 0xfb, 0xfe, 0xe5, 0x46, 0xee, 0x1f, 0x2f, 0x37, 0x72, 0xdf, 0xbc,
0xda, 0x58, 0xf9, 0xee, 0xd5, 0xc6, 0xca, 0xf7, 0xaf, 0x36, 0x56, 0x4e, 0xca, 0xf4, 0x0f, 0xf8,
0xb3, 0xff, 0x04, 0x00, 0x00, 0xff, 0xff, 0x9e, 0x8a, 0x26, 0xee, 0x43, 0x16, 0x00, 0x00,
}
func (m *Op) Marshal() (dAtA []byte, err error) {
@ -2921,11 +2965,6 @@ func (m *Meta) MarshalToSizedBuffer(dAtA []byte) (int, error) {
dAtA[i] = 0x4a
}
}
if m.ShmSize != 0 {
i = encodeVarintOps(dAtA, i, uint64(m.ShmSize))
i--
dAtA[i] = 0x40
}
if len(m.Hostname) > 0 {
i -= len(m.Hostname)
copy(dAtA[i:], m.Hostname)
@ -3142,6 +3181,20 @@ func (m *Mount) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i--
dAtA[i] = 0xa2
}
if m.TmpfsOpt != nil {
{
size, err := m.TmpfsOpt.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintOps(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x1
i--
dAtA[i] = 0x9a
}
if m.MountType != 0 {
i = encodeVarintOps(dAtA, i, uint64(m.MountType))
i--
@ -3184,6 +3237,34 @@ func (m *Mount) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *TmpfsOpt) 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 *TmpfsOpt) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *TmpfsOpt) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.Size_ != 0 {
i = encodeVarintOps(dAtA, i, uint64(m.Size_))
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
func (m *CacheOpt) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@ -4890,9 +4971,6 @@ func (m *Meta) Size() (n int) {
if l > 0 {
n += 1 + l + sovOps(uint64(l))
}
if m.ShmSize != 0 {
n += 1 + sovOps(uint64(m.ShmSize))
}
if len(m.Ulimit) > 0 {
for _, e := range m.Ulimit {
l = e.Size()
@ -4964,6 +5042,10 @@ func (m *Mount) Size() (n int) {
if m.MountType != 0 {
n += 1 + sovOps(uint64(m.MountType))
}
if m.TmpfsOpt != nil {
l = m.TmpfsOpt.Size()
n += 2 + l + sovOps(uint64(l))
}
if m.CacheOpt != nil {
l = m.CacheOpt.Size()
n += 2 + l + sovOps(uint64(l))
@ -4983,6 +5065,18 @@ func (m *Mount) Size() (n int) {
return n
}
func (m *TmpfsOpt) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.Size_ != 0 {
n += 1 + sovOps(uint64(m.Size_))
}
return n
}
func (m *CacheOpt) Size() (n int) {
if m == nil {
return 0
@ -6654,25 +6748,6 @@ func (m *Meta) Unmarshal(dAtA []byte) error {
}
m.Hostname = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 8:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field ShmSize", wireType)
}
m.ShmSize = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowOps
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.ShmSize |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 9:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Ulimit", wireType)
@ -7132,6 +7207,42 @@ func (m *Mount) Unmarshal(dAtA []byte) error {
break
}
}
case 19:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field TmpfsOpt", 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.TmpfsOpt == nil {
m.TmpfsOpt = &TmpfsOpt{}
}
if err := m.TmpfsOpt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 20:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field CacheOpt", wireType)
@ -7293,6 +7404,75 @@ func (m *Mount) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *TmpfsOpt) 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: TmpfsOpt: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: TmpfsOpt: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Size_", wireType)
}
m.Size_ = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowOps
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Size_ |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipOps(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (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

8
solver/pb/ops.proto
View File

@ -58,7 +58,6 @@ message Meta {
ProxyEnv proxy_env = 5;
repeated HostIP extraHosts = 6;
string hostname = 7;
int64 shmSize = 8;
repeated Ulimit ulimit = 9;
}
@ -92,6 +91,7 @@ message Mount {
int64 output = 4 [(gogoproto.customtype) = "OutputIndex", (gogoproto.nullable) = false];
bool readonly = 5;
MountType mountType = 6;
TmpfsOpt TmpfsOpt = 19;
CacheOpt cacheOpt = 20;
SecretOpt secretOpt = 21;
SSHOpt SSHOpt = 22;
@ -107,6 +107,12 @@ enum MountType {
TMPFS = 4;
}
// TmpfsOpt defines options describing tpmfs mounts
message TmpfsOpt {
// Specify an upper limit on the size of the filesystem.
int64 size = 1;
}
// CacheOpt defines options specific to cache mounts
message CacheOpt {
// ID is an optional namespace for the mount