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

Merge pull request #400 from tonistiigi/proxy-args 

Add proxy args support
docker-18.09
Akihiro Suda 2018-05-22 16:04:12 +09:00 committed by GitHub
parent d3eacf02f8 286cf44db3
commit 779d8fa5b2
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 683 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
client/client_test.go
View File

@ -48,6 +48,7 @@ func TestClientIntegration(t *testing.T) {
testReadonlyRootFS,
testBasicCacheImportExport,
testCachedMounts,
testProxyEnv,
})
}
@ -895,6 +896,65 @@ func testReadonlyRootFS(t *testing.T, sb integration.Sandbox) {
checkAllReleasable(t, c, sb, true)
}
func testProxyEnv(t *testing.T, sb integration.Sandbox) {
t.Parallel()
c, err := New(sb.Address())
require.NoError(t, err)
defer c.Close()
base := llb.Image("docker.io/library/busybox:latest").Dir("/out")
cmd := `sh -c "echo -n $HTTP_PROXY-$HTTPS_PROXY-$NO_PROXY-$no_proxy > env"`
st := base.Run(llb.Shlex(cmd), llb.WithProxy(llb.ProxyEnv{
HttpProxy: "httpvalue",
HttpsProxy: "httpsvalue",
NoProxy: "noproxyvalue",
}))
out := st.AddMount("/out", llb.Scratch())
def, err := out.Marshal()
require.NoError(t, err)
destDir, err := ioutil.TempDir("", "buildkit")
require.NoError(t, err)
defer os.RemoveAll(destDir)
_, err = c.Solve(context.TODO(), def, SolveOpt{
Exporter: ExporterLocal,
ExporterOutputDir: destDir,
}, nil)
require.NoError(t, err)
dt, err := ioutil.ReadFile(filepath.Join(destDir, "env"))
require.NoError(t, err)
require.Equal(t, string(dt), "httpvalue-httpsvalue-noproxyvalue-noproxyvalue")
// repeat to make sure proxy doesn't change cache
st = base.Run(llb.Shlex(cmd), llb.WithProxy(llb.ProxyEnv{
HttpsProxy: "httpsvalue2",
NoProxy: "noproxyvalue2",
}))
out = st.AddMount("/out", llb.Scratch())
def, err = out.Marshal()
require.NoError(t, err)
destDir, err = ioutil.TempDir("", "buildkit")
require.NoError(t, err)
defer os.RemoveAll(destDir)
_, err = c.Solve(context.TODO(), def, SolveOpt{
Exporter: ExporterLocal,
ExporterOutputDir: destDir,
}, nil)
require.NoError(t, err)
dt, err = ioutil.ReadFile(filepath.Join(destDir, "env"))
require.NoError(t, err)
require.Equal(t, string(dt), "httpvalue-httpsvalue-noproxyvalue-noproxyvalue")
}
func requiresLinux(t *testing.T) {
if runtime.GOOS != "linux" {
t.Skipf("unsupported GOOS: %s", runtime.GOOS)

32
client/llb/exec.go
View File

@ -10,10 +10,11 @@ import (
)
type Meta struct {
Args []string
Env EnvList
Cwd string
User string
Args []string
Env EnvList
Cwd string
User string
ProxyEnv *ProxyEnv
}
func NewExecOp(root Output, meta Meta, readOnly bool, md OpMetadata) *ExecOp {
@ -124,6 +125,15 @@ func (e *ExecOp) Marshal() (digest.Digest, []byte, *OpMetadata, error) {
},
}
if p := e.meta.ProxyEnv; p != nil {
peo.Meta.ProxyEnv = &pb.ProxyEnv{
HttpProxy: p.HttpProxy,
HttpsProxy: p.HttpsProxy,
FtpProxy: p.FtpProxy,
NoProxy: p.NoProxy,
}
}
pop := &pb.Op{
Op: &pb.Op_Exec{
Exec: peo,
@ -334,11 +344,18 @@ func ReadonlyRootFS() RunOption {
})
}
func WithProxy(ps ProxyEnv) RunOption {
return runOptionFunc(func(ei *ExecInfo) {
ei.ProxyEnv = &ps
})
}
type ExecInfo struct {
opMetaWrapper
State State
Mounts []MountInfo
ReadonlyRootFS bool
ProxyEnv *ProxyEnv
}
type MountInfo struct {
@ -346,3 +363,10 @@ type MountInfo struct {
Source Output
Opts []MountOption
}
type ProxyEnv struct {
HttpProxy string
HttpsProxy string
FtpProxy string
NoProxy string
}

13
client/llb/state.go
View File

@ -125,10 +125,11 @@ func (s State) Run(ro ...RunOption) ExecState {
o.SetRunOption(ei)
}
meta := Meta{
Args: getArgs(ei.State),
Cwd: getDir(ei.State),
Env: getEnv(ei.State),
User: getUser(ei.State),
Args: getArgs(ei.State),
Cwd: getDir(ei.State),
Env: getEnv(ei.State),
User: getUser(ei.State),
ProxyEnv: ei.ProxyEnv,
}
exec := NewExecOp(s.Output(), meta, ei.ReadonlyRootFS, ei.Metadata())
@ -256,6 +257,10 @@ func mergeMetadata(m1, m2 OpMetadata) OpMetadata {
m1.Description[k] = v
}
}
if m2.ExportCache != nil {
m1.ExportCache = m2.ExportCache
}
return m1
}

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

@ -56,6 +56,8 @@ func Dockerfile2LLB(ctx context.Context, dt []byte, opt ConvertOpt) (*llb.State,
return nil, nil, err
}
proxyEnv := proxyEnvFromBuildArgs(opt.BuildArgs)
stages, metaArgs, err := instructions.Parse(dockerfile.AST)
if err != nil {
return nil, nil, err
@ -226,6 +228,7 @@ func Dockerfile2LLB(ctx context.Context, dt []byte, opt ConvertOpt) (*llb.State,
shlex: shlex,
sessionID: opt.SessionID,
buildContext: llb.NewState(buildContext),
proxyEnv: proxyEnv,
}
if err = dispatchOnBuild(d, d.image.Config.OnBuild, opt); err != nil {
@ -303,6 +306,7 @@ type dispatchOpt struct {
shlex *shell.Lex
sessionID string
buildContext llb.State
proxyEnv *llb.ProxyEnv
}
func dispatch(d *dispatchState, cmd command, opt dispatchOpt) error {
@ -322,7 +326,7 @@ func dispatch(d *dispatchState, cmd command, opt dispatchOpt) error {
case *instructions.EnvCommand:
err = dispatchEnv(d, c, true)
case *instructions.RunCommand:
err = dispatchRun(d, c)
err = dispatchRun(d, c, opt.proxyEnv)
case *instructions.WorkdirCommand:
err = dispatchWorkdir(d, c, true)
case *instructions.AddCommand:
@ -424,7 +428,7 @@ func dispatchEnv(d *dispatchState, c *instructions.EnvCommand, commit bool) erro
return nil
}
func dispatchRun(d *dispatchState, c *instructions.RunCommand) error {
func dispatchRun(d *dispatchState, c *instructions.RunCommand, proxy *llb.ProxyEnv) error {
var args []string = c.CmdLine
if c.PrependShell {
args = append(defaultShell(), strings.Join(args, " "))
@ -439,6 +443,9 @@ func dispatchRun(d *dispatchState, c *instructions.RunCommand) error {
if d.ignoreCache {
opt = append(opt, llb.IgnoreCache)
}
if proxy != nil {
opt = append(opt, llb.WithProxy(*proxy))
}
d.state = d.state.Run(opt...).Root()
return commitToHistory(&d.image, "RUN "+runCommandString(args, d.buildArgs), true, &d.state)
}
@ -851,6 +858,33 @@ func normalizeContextPaths(paths map[string]struct{}) []string {
return toSort
}
func proxyEnvFromBuildArgs(args map[string]string) *llb.ProxyEnv {
pe := &llb.ProxyEnv{}
isNil := true
for k, v := range args {
if strings.EqualFold(k, "http_proxy") {
pe.HttpProxy = v
isNil = false
}
if strings.EqualFold(k, "https_proxy") {
pe.HttpsProxy = v
isNil = false
}
if strings.EqualFold(k, "ftp_proxy") {
pe.FtpProxy = v
isNil = false
}
if strings.EqualFold(k, "no_proxy") {
pe.NoProxy = v
isNil = false
}
}
if isNil {
return nil
}
return pe
}
type mutableOutput struct {
llb.Output
}

103
frontend/dockerfile/dockerfile_test.go
View File

@ -59,6 +59,7 @@ func TestIntegration(t *testing.T) {
testImportExportReproducibleIDs,
testNoCache,
testDockerfileFromHTTP,
testBuiltinArgs,
})
}
@ -1767,6 +1768,108 @@ COPY --from=s1 unique2 /
require.NotEqual(t, string(unique2Dir1), string(unique2Dir3))
}
func testBuiltinArgs(t *testing.T, sb integration.Sandbox) {
t.Parallel()
dockerfile := []byte(`
FROM busybox AS build
ARG FOO
ARG BAR
ARG BAZ=bazcontent
RUN echo -n $HTTP_PROXY::$NO_PROXY::$FOO::$BAR::$BAZ > /out
FROM scratch
COPY --from=build /out /
`)
dir, err := tmpdir(
fstest.CreateFile("Dockerfile", dockerfile, 0600),
)
require.NoError(t, err)
defer os.RemoveAll(dir)
c, err := client.New(sb.Address())
require.NoError(t, err)
defer c.Close()
destDir, err := ioutil.TempDir("", "buildkit")
require.NoError(t, err)
defer os.RemoveAll(destDir)
opt := client.SolveOpt{
Frontend: "dockerfile.v0",
FrontendAttrs: map[string]string{
"build-arg:FOO": "foocontents",
"build-arg:http_proxy": "hpvalue",
"build-arg:NO_PROXY": "npvalue",
},
Exporter: client.ExporterLocal,
ExporterOutputDir: destDir,
LocalDirs: map[string]string{
builder.LocalNameDockerfile: dir,
builder.LocalNameContext: dir,
},
}
_, err = c.Solve(context.TODO(), nil, opt, nil)
require.NoError(t, err)
dt, err := ioutil.ReadFile(filepath.Join(destDir, "out"))
require.NoError(t, err)
require.Equal(t, string(dt), "hpvalue::npvalue::foocontents::::bazcontent")
// repeat with changed default args should match the old cache
destDir, err = ioutil.TempDir("", "buildkit")
require.NoError(t, err)
defer os.RemoveAll(destDir)
opt = client.SolveOpt{
Frontend: "dockerfile.v0",
FrontendAttrs: map[string]string{
"build-arg:FOO": "foocontents",
"build-arg:http_proxy": "hpvalue2",
},
Exporter: client.ExporterLocal,
ExporterOutputDir: destDir,
LocalDirs: map[string]string{
builder.LocalNameDockerfile: dir,
builder.LocalNameContext: dir,
},
}
_, err = c.Solve(context.TODO(), nil, opt, nil)
require.NoError(t, err)
dt, err = ioutil.ReadFile(filepath.Join(destDir, "out"))
require.NoError(t, err)
require.Equal(t, string(dt), "hpvalue::npvalue::foocontents::::bazcontent")
// changing actual value invalidates cache
destDir, err = ioutil.TempDir("", "buildkit")
require.NoError(t, err)
defer os.RemoveAll(destDir)
opt = client.SolveOpt{
Frontend: "dockerfile.v0",
FrontendAttrs: map[string]string{
"build-arg:FOO": "foocontents2",
"build-arg:http_proxy": "hpvalue2",
},
Exporter: client.ExporterLocal,
ExporterOutputDir: destDir,
LocalDirs: map[string]string{
builder.LocalNameDockerfile: dir,
builder.LocalNameContext: dir,
},
}
_, err = c.Solve(context.TODO(), nil, opt, nil)
require.NoError(t, err)
dt, err = ioutil.ReadFile(filepath.Join(destDir, "out"))
require.NoError(t, err)
require.Equal(t, string(dt), "hpvalue2::::foocontents2::::bazcontent")
}
func tmpdir(appliers ...fstest.Applier) (string, error) {
tmpdir, err := ioutil.TempDir("", "buildkit-dockerfile")
if err != nil {

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

@ -36,6 +36,8 @@ type execOp struct {
}
func NewExecOp(v solver.Vertex, op *pb.Op_Exec, cm cache.Manager, md *metadata.Store, exec executor.Executor, w worker.Worker) (solver.Op, error) {
logrus.Debugf("newexecop %#v", op.Exec.Meta)
return &execOp{
op: op.Exec,
cm: cm,
@ -48,6 +50,8 @@ func NewExecOp(v solver.Vertex, op *pb.Op_Exec, cm cache.Manager, md *metadata.S
func cloneExecOp(old *pb.ExecOp) pb.ExecOp {
n := *old
meta := *n.Meta
n.Meta = &meta
n.Mounts = nil
for i := range n.Mounts {
m := *n.Mounts[i]
@ -61,6 +65,7 @@ func (e *execOp) CacheMap(ctx context.Context, index int) (*solver.CacheMap, boo
for i := range op.Mounts {
op.Mounts[i].Selector = ""
}
op.Meta.ProxyEnv = nil
dt, err := json.Marshal(struct {
Type string
@ -315,6 +320,10 @@ func (e *execOp) Exec(ctx context.Context, inputs []solver.Result) ([]solver.Res
ReadonlyRootFS: readonlyRootFS,
}
if e.op.Meta.ProxyEnv != nil {
meta.Env = append(meta.Env, proxyEnvList(e.op.Meta.ProxyEnv)...)
}
stdout, stderr := logs.NewLogStreams(ctx)
defer stdout.Close()
defer stderr.Close()
@ -338,3 +347,20 @@ func (e *execOp) Exec(ctx context.Context, inputs []solver.Result) ([]solver.Res
}
return refs, nil
}
func proxyEnvList(p *pb.ProxyEnv) []string {
out := []string{}
if v := p.HttpProxy; v != "" {
out = append(out, "HTTP_PROXY="+v, "http_proxy="+v)
}
if v := p.HttpsProxy; v != "" {
out = append(out, "HTTPS_PROXY="+v, "https_proxy="+v)
}
if v := p.FtpProxy; v != "" {
out = append(out, "FTP_PROXY="+v, "ftp_proxy="+v)
}
if v := p.NoProxy; v != "" {
out = append(out, "NO_PROXY="+v, "no_proxy="+v)
}
return out
}

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

@ -24,6 +24,7 @@
BuildInput
OpMetadata
ExportCache
ProxyEnv
WorkerConstraint
Definition
*/
@ -313,10 +314,11 @@ func (m *ExecOp) GetMounts() []*Mount {
// Meta is unrelated to LLB metadata.
// FIXME: rename (ExecContext? ExecArgs?)
type Meta struct {
Args []string `protobuf:"bytes,1,rep,name=args" json:"args,omitempty"`
Env []string `protobuf:"bytes,2,rep,name=env" 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"`
Args []string `protobuf:"bytes,1,rep,name=args" json:"args,omitempty"`
Env []string `protobuf:"bytes,2,rep,name=env" 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" json:"proxy_env,omitempty"`
}
func (m *Meta) Reset() { *m = Meta{} }
@ -352,6 +354,13 @@ func (m *Meta) GetUser() string {
return ""
}
func (m *Meta) GetProxyEnv() *ProxyEnv {
if m != nil {
return m.ProxyEnv
}
return nil
}
// 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"`
@ -593,6 +602,46 @@ func (m *ExportCache) GetValue() bool {
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 fileDescriptorOps, []int{13} }
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 ""
}
// WorkerConstraint is experimental and likely to be changed.
type WorkerConstraint struct {
Filter []string `protobuf:"bytes,1,rep,name=filter" json:"filter,omitempty"`
@ -601,7 +650,7 @@ type WorkerConstraint struct {
func (m *WorkerConstraint) Reset() { *m = WorkerConstraint{} }
func (m *WorkerConstraint) String() string { return proto.CompactTextString(m) }
func (*WorkerConstraint) ProtoMessage() {}
func (*WorkerConstraint) Descriptor() ([]byte, []int) { return fileDescriptorOps, []int{13} }
func (*WorkerConstraint) Descriptor() ([]byte, []int) { return fileDescriptorOps, []int{14} }
func (m *WorkerConstraint) GetFilter() []string {
if m != nil {
@ -622,7 +671,7 @@ type Definition struct {
func (m *Definition) Reset() { *m = Definition{} }
func (m *Definition) String() string { return proto.CompactTextString(m) }
func (*Definition) ProtoMessage() {}
func (*Definition) Descriptor() ([]byte, []int) { return fileDescriptorOps, []int{14} }
func (*Definition) Descriptor() ([]byte, []int) { return fileDescriptorOps, []int{15} }
func (m *Definition) GetDef() [][]byte {
if m != nil {
@ -652,6 +701,7 @@ func init() {
proto.RegisterType((*BuildInput)(nil), "pb.BuildInput")
proto.RegisterType((*OpMetadata)(nil), "pb.OpMetadata")
proto.RegisterType((*ExportCache)(nil), "pb.ExportCache")
proto.RegisterType((*ProxyEnv)(nil), "pb.ProxyEnv")
proto.RegisterType((*WorkerConstraint)(nil), "pb.WorkerConstraint")
proto.RegisterType((*Definition)(nil), "pb.Definition")
proto.RegisterEnum("pb.MountType", MountType_name, MountType_value)
@ -875,6 +925,16 @@ func (m *Meta) MarshalTo(dAtA []byte) (int, error) {
i = encodeVarintOps(dAtA, i, uint64(len(m.User)))
i += copy(dAtA[i:], m.User)
}
if m.ProxyEnv != nil {
dAtA[i] = 0x2a
i++
i = encodeVarintOps(dAtA, i, uint64(m.ProxyEnv.Size()))
n7, err := m.ProxyEnv.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n7
}
return i, nil
}
@ -936,11 +996,11 @@ func (m *Mount) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x1
i++
i = encodeVarintOps(dAtA, i, uint64(m.CacheOpt.Size()))
n7, err := m.CacheOpt.MarshalTo(dAtA[i:])
n8, err := m.CacheOpt.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n7
i += n8
}
return i, nil
}
@ -1115,11 +1175,11 @@ func (m *BuildOp) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x12
i++
i = encodeVarintOps(dAtA, i, uint64(v.Size()))
n8, err := v.MarshalTo(dAtA[i:])
n9, err := v.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n8
i += n9
}
}
}
@ -1127,11 +1187,11 @@ func (m *BuildOp) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x1a
i++
i = encodeVarintOps(dAtA, i, uint64(m.Def.Size()))
n9, err := m.Def.MarshalTo(dAtA[i:])
n10, err := m.Def.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n9
i += n10
}
if len(m.Attrs) > 0 {
for k, _ := range m.Attrs {
@ -1222,21 +1282,21 @@ func (m *OpMetadata) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x1a
i++
i = encodeVarintOps(dAtA, i, uint64(m.WorkerConstraint.Size()))
n10, err := m.WorkerConstraint.MarshalTo(dAtA[i:])
n11, err := m.WorkerConstraint.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n10
i += n11
}
if m.ExportCache != nil {
dAtA[i] = 0x22
i++
i = encodeVarintOps(dAtA, i, uint64(m.ExportCache.Size()))
n11, err := m.ExportCache.MarshalTo(dAtA[i:])
n12, err := m.ExportCache.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n11
i += n12
}
return i, nil
}
@ -1269,6 +1329,48 @@ func (m *ExportCache) MarshalTo(dAtA []byte) (int, error) {
return i, nil
}
func (m *ProxyEnv) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *ProxyEnv) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.HttpProxy) > 0 {
dAtA[i] = 0xa
i++
i = encodeVarintOps(dAtA, i, uint64(len(m.HttpProxy)))
i += copy(dAtA[i:], m.HttpProxy)
}
if len(m.HttpsProxy) > 0 {
dAtA[i] = 0x12
i++
i = encodeVarintOps(dAtA, i, uint64(len(m.HttpsProxy)))
i += copy(dAtA[i:], m.HttpsProxy)
}
if len(m.FtpProxy) > 0 {
dAtA[i] = 0x1a
i++
i = encodeVarintOps(dAtA, i, uint64(len(m.FtpProxy)))
i += copy(dAtA[i:], m.FtpProxy)
}
if len(m.NoProxy) > 0 {
dAtA[i] = 0x22
i++
i = encodeVarintOps(dAtA, i, uint64(len(m.NoProxy)))
i += copy(dAtA[i:], m.NoProxy)
}
return i, nil
}
func (m *WorkerConstraint) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@ -1344,11 +1446,11 @@ func (m *Definition) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x12
i++
i = encodeVarintOps(dAtA, i, uint64((&v).Size()))
n12, err := (&v).MarshalTo(dAtA[i:])
n13, err := (&v).MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n12
i += n13
}
}
return i, nil
@ -1466,6 +1568,10 @@ func (m *Meta) Size() (n int) {
if l > 0 {
n += 1 + l + sovOps(uint64(l))
}
if m.ProxyEnv != nil {
l = m.ProxyEnv.Size()
n += 1 + l + sovOps(uint64(l))
}
return n
}
@ -1633,6 +1739,28 @@ func (m *ExportCache) Size() (n int) {
return n
}
func (m *ProxyEnv) Size() (n int) {
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 *WorkerConstraint) Size() (n int) {
var l int
_ = l
@ -2245,6 +2373,39 @@ func (m *Meta) Unmarshal(dAtA []byte) error {
}
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 > 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
default:
iNdEx = preIndex
skippy, err := skipOps(dAtA[iNdEx:])
@ -3704,6 +3865,172 @@ func (m *ExportCache) Unmarshal(dAtA []byte) error {
}
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 > 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 > 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 > 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 > 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) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *WorkerConstraint) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
@ -4093,66 +4420,71 @@ var (
func init() { proto.RegisterFile("ops.proto", fileDescriptorOps) }
var fileDescriptorOps = []byte{
// 972 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0x5f, 0x8f, 0xdb, 0x44,
0x10, 0x3f, 0x3b, 0x89, 0x2f, 0x1e, 0x5f, 0x8f, 0xb0, 0x9c, 0x4a, 0x14, 0x55, 0xb9, 0xe0, 0x22,
0x14, 0xae, 0xbd, 0x9c, 0x14, 0x04, 0xaa, 0x78, 0xa8, 0x74, 0xf9, 0x23, 0x5d, 0x40, 0x25, 0xd2,
0x5e, 0x05, 0x8f, 0x95, 0x63, 0x6f, 0x52, 0xab, 0x39, 0xef, 0xca, 0x5e, 0xf7, 0x2e, 0x2f, 0x48,
0xf0, 0x09, 0x90, 0xf8, 0x14, 0x7c, 0x08, 0x78, 0xee, 0x23, 0xaf, 0xf0, 0x50, 0xd0, 0xf1, 0x45,
0xd0, 0xce, 0x6e, 0x6c, 0xf7, 0x28, 0x52, 0x2b, 0x78, 0xca, 0xee, 0xcc, 0xec, 0x6f, 0x66, 0x7e,
0xfb, 0xdb, 0x71, 0xc0, 0xe5, 0x22, 0x1b, 0x88, 0x94, 0x4b, 0x4e, 0x6c, 0xb1, 0xe8, 0x1c, 0xaf,
0x62, 0xf9, 0x34, 0x5f, 0x0c, 0x42, 0x7e, 0x71, 0xb2, 0xe2, 0x2b, 0x7e, 0x82, 0xae, 0x45, 0xbe,
0xc4, 0x1d, 0x6e, 0x70, 0xa5, 0x8f, 0xf8, 0xbf, 0x58, 0x60, 0xcf, 0x05, 0xf9, 0x00, 0x9c, 0x38,
0x11, 0xb9, 0xcc, 0xda, 0x56, 0xaf, 0xd6, 0xf7, 0x86, 0xee, 0x40, 0x2c, 0x06, 0x33, 0x65, 0xa1,
0xc6, 0x41, 0x7a, 0x50, 0x67, 0x57, 0x2c, 0x6c, 0xdb, 0x3d, 0xab, 0xef, 0x0d, 0x41, 0x05, 0x4c,
0xaf, 0x58, 0x38, 0x17, 0x67, 0x3b, 0x14, 0x3d, 0xe4, 0x23, 0x70, 0x32, 0x9e, 0xa7, 0x21, 0x6b,
0xd7, 0x30, 0x66, 0x4f, 0xc5, 0x9c, 0xa3, 0x05, 0xa3, 0x8c, 0x57, 0x21, 0x85, 0x5c, 0x6c, 0xda,
0xf5, 0x12, 0x69, 0xcc, 0xc5, 0x46, 0x23, 0x29, 0x0f, 0xb9, 0x0b, 0x8d, 0x45, 0x1e, 0xaf, 0xa3,
0x76, 0x03, 0x43, 0x3c, 0x15, 0x32, 0x52, 0x06, 0x8c, 0xd1, 0xbe, 0x51, 0x1d, 0x6c, 0x2e, 0xfc,
0x6f, 0xa1, 0x81, 0x75, 0x92, 0x2f, 0xc0, 0x89, 0xe2, 0x15, 0xcb, 0x64, 0xdb, 0xea, 0x59, 0x7d,
0x77, 0x34, 0x7c, 0xf1, 0xf2, 0x70, 0xe7, 0xf7, 0x97, 0x87, 0x47, 0x15, 0x42, 0xb8, 0x60, 0x49,
0xc8, 0x13, 0x19, 0xc4, 0x09, 0x4b, 0xb3, 0x93, 0x15, 0x3f, 0xd6, 0x47, 0x06, 0x13, 0xfc, 0xa1,
0x06, 0x81, 0x7c, 0x0c, 0x8d, 0x38, 0x89, 0xd8, 0x15, 0x36, 0x5b, 0x1b, 0xbd, 0x67, 0xa0, 0xbc,
0x79, 0x2e, 0x45, 0x2e, 0x67, 0xca, 0x45, 0x75, 0x84, 0x3f, 0x03, 0x47, 0xd3, 0x40, 0xee, 0x40,
0xfd, 0x82, 0xc9, 0x00, 0xd3, 0x7b, 0xc3, 0xa6, 0xaa, 0xf9, 0x11, 0x93, 0x01, 0x45, 0xab, 0x62,
0xf8, 0x82, 0xe7, 0x89, 0xcc, 0xda, 0x76, 0xc9, 0xf0, 0x23, 0x65, 0xa1, 0xc6, 0xe1, 0x53, 0xa8,
0xab, 0x03, 0x84, 0x40, 0x3d, 0x48, 0x57, 0xfa, 0x2a, 0x5c, 0x8a, 0x6b, 0xd2, 0x82, 0x1a, 0x4b,
0x9e, 0xe3, 0x59, 0x97, 0xaa, 0xa5, 0xb2, 0x84, 0x97, 0x11, 0x52, 0xed, 0x52, 0xb5, 0x54, 0xe7,
0xf2, 0x8c, 0xa5, 0xc8, 0xab, 0x4b, 0x71, 0xed, 0x7f, 0x67, 0x43, 0x03, 0xb3, 0x90, 0xbe, 0xea,
0x49, 0xe4, 0x9a, 0x9e, 0xda, 0x88, 0x98, 0x9e, 0x00, 0xd9, 0x2b, 0x5a, 0x52, 0x4c, 0x76, 0xa0,
0x99, 0xb1, 0x35, 0x0b, 0x25, 0x4f, 0x91, 0x00, 0x97, 0x16, 0x7b, 0x95, 0x23, 0x52, 0x1c, 0xeb,
0xb4, 0xb8, 0x26, 0xf7, 0xc0, 0xe1, 0x48, 0x0c, 0x66, 0xfe, 0x17, 0xba, 0x4c, 0x88, 0x02, 0x4f,
0x59, 0x10, 0xf1, 0x64, 0xbd, 0xc1, 0xdb, 0x6d, 0xd2, 0x62, 0x4f, 0xee, 0x81, 0x8b, 0x54, 0x3c,
0xde, 0x08, 0xd6, 0x76, 0x7a, 0x56, 0x7f, 0x7f, 0x78, 0xab, 0xa0, 0x49, 0x19, 0x69, 0xe9, 0x27,
0x7d, 0x68, 0x86, 0x41, 0xf8, 0x94, 0xcd, 0x85, 0x6c, 0x1f, 0x94, 0x7a, 0x1b, 0x1b, 0x1b, 0x2d,
0xbc, 0x7e, 0x07, 0x9a, 0x5b, 0x2b, 0xd9, 0x07, 0x7b, 0x36, 0xd1, 0x0a, 0xa1, 0xf6, 0x6c, 0xe2,
0x3f, 0x04, 0x47, 0x6b, 0x8f, 0xf4, 0xa0, 0x96, 0xa5, 0xa1, 0xd1, 0xff, 0xfe, 0x56, 0x94, 0x5a,
0xbe, 0x54, 0xb9, 0x8a, 0xde, 0xed, 0xb2, 0x77, 0x9f, 0x02, 0x94, 0x61, 0xff, 0x0f, 0xc7, 0xfe,
0x8f, 0x16, 0x34, 0xb7, 0xcf, 0x86, 0x74, 0x01, 0xe2, 0x88, 0x25, 0x32, 0x5e, 0xc6, 0x2c, 0x35,
0x85, 0x57, 0x2c, 0xe4, 0x18, 0x1a, 0x81, 0x94, 0xe9, 0x56, 0x56, 0xef, 0x57, 0xdf, 0xdc, 0xe0,
0x54, 0x79, 0xa6, 0x89, 0x4c, 0x37, 0x54, 0x47, 0x75, 0x1e, 0x00, 0x94, 0x46, 0xa5, 0xa1, 0x67,
0x6c, 0x63, 0x50, 0xd5, 0x92, 0x1c, 0x40, 0xe3, 0x79, 0xb0, 0xce, 0x99, 0x29, 0x4a, 0x6f, 0x3e,
0xb7, 0x1f, 0x58, 0xfe, 0xcf, 0x36, 0xec, 0x9a, 0x37, 0x48, 0xee, 0xc3, 0x2e, 0xbe, 0x41, 0x53,
0xd1, 0xeb, 0x3b, 0xdd, 0x86, 0x90, 0x93, 0x62, 0xb8, 0x54, 0x6a, 0x34, 0x50, 0x7a, 0xc8, 0x98,
0x1a, 0xcb, 0x51, 0x53, 0x8b, 0xd8, 0xd2, 0x4c, 0x11, 0xbc, 0x8a, 0x09, 0x5b, 0xc6, 0x49, 0x2c,
0x63, 0x9e, 0x50, 0xe5, 0x22, 0xf7, 0xb7, 0x5d, 0xd7, 0x11, 0xf1, 0x76, 0x15, 0xf1, 0x9f, 0x4d,
0xcf, 0xc0, 0xab, 0xa4, 0x79, 0x4d, 0xd7, 0x1f, 0x56, 0xbb, 0x36, 0x29, 0x11, 0x4e, 0x8f, 0xc0,
0x92, 0x85, 0xff, 0xc0, 0xdf, 0x67, 0x00, 0x25, 0xe4, 0x9b, 0x2b, 0xc5, 0xff, 0xc9, 0x06, 0x98,
0x0b, 0x35, 0x18, 0xa2, 0x00, 0xe7, 0xc8, 0x5e, 0xbc, 0x4a, 0x78, 0xca, 0x9e, 0xa0, 0xbe, 0xf1,
0x7c, 0x93, 0x7a, 0xda, 0x86, 0x32, 0x27, 0xa7, 0xe0, 0x45, 0x2c, 0x0b, 0xd3, 0x58, 0x28, 0xc2,
0x0c, 0xe9, 0x87, 0xaa, 0xa7, 0x12, 0x67, 0x30, 0x29, 0x23, 0x34, 0x57, 0xd5, 0x33, 0xe4, 0x14,
0xde, 0xbd, 0xe4, 0xe9, 0x33, 0x96, 0x3e, 0x09, 0x79, 0x92, 0xc9, 0x34, 0x88, 0x13, 0x69, 0xee,
0xe3, 0x40, 0x01, 0x7d, 0x83, 0xce, 0x71, 0xe1, 0xa3, 0xad, 0xcb, 0x1b, 0x16, 0x32, 0x84, 0x3d,
0x76, 0x25, 0x78, 0x2a, 0x4d, 0xa1, 0x7a, 0xda, 0xbf, 0xa3, 0xbf, 0x1b, 0xca, 0x8e, 0xc5, 0x52,
0x8f, 0x95, 0x9b, 0xce, 0x43, 0x68, 0xdd, 0xac, 0xeb, 0xad, 0x38, 0xbe, 0x0b, 0x5e, 0x05, 0x5b,
0x05, 0x7e, 0x8d, 0x81, 0x9a, 0x24, 0xbd, 0xf1, 0x8f, 0xa0, 0x75, 0xb3, 0x7c, 0x72, 0x1b, 0x9c,
0x65, 0xbc, 0x96, 0xa8, 0x67, 0x35, 0x61, 0xcd, 0xce, 0xff, 0xcd, 0x02, 0x28, 0xb5, 0xa7, 0x6a,
0x51, 0xc2, 0x54, 0x31, 0x7b, 0x5a, 0x88, 0x6b, 0x68, 0x5e, 0x18, 0x4a, 0x0d, 0xd1, 0x77, 0x5e,
0xd5, 0xeb, 0x60, 0xcb, 0x38, 0x76, 0xa3, 0xbf, 0x4a, 0xdf, 0xff, 0xf1, 0x56, 0x5f, 0xa5, 0x22,
0x43, 0xe7, 0x4b, 0xb8, 0xf5, 0x0a, 0xdc, 0x1b, 0x4a, 0xb9, 0xbc, 0xf6, 0x0a, 0x59, 0x47, 0x9f,
0x82, 0x5b, 0x0c, 0x56, 0xd2, 0x84, 0xfa, 0x68, 0xf6, 0xd5, 0xa4, 0xb5, 0x43, 0x00, 0x9c, 0xf3,
0xe9, 0x98, 0x4e, 0x1f, 0xb7, 0x2c, 0xb2, 0x0b, 0xb5, 0xf3, 0xf3, 0xb3, 0x96, 0x4d, 0x5c, 0x68,
0x8c, 0x4f, 0xc7, 0x67, 0xd3, 0x56, 0x6d, 0xd4, 0x7a, 0x71, 0xdd, 0xb5, 0x7e, 0xbd, 0xee, 0x5a,
0x7f, 0x5e, 0x77, 0xad, 0x1f, 0xfe, 0xea, 0xee, 0x2c, 0x1c, 0xfc, 0x2b, 0xf1, 0xc9, 0xdf, 0x01,
0x00, 0x00, 0xff, 0xff, 0xd8, 0x84, 0x48, 0xaf, 0x8a, 0x08, 0x00, 0x00,
// 1053 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xdd, 0x6e, 0x1b, 0xc5,
0x17, 0xcf, 0xae, 0x3f, 0xb2, 0x7b, 0x36, 0xcd, 0xdf, 0xff, 0x21, 0x2a, 0xc6, 0x94, 0xc4, 0x6c,
0x11, 0x72, 0xd3, 0xc6, 0x91, 0x8c, 0x40, 0x15, 0x17, 0x95, 0xe2, 0x0f, 0x29, 0x06, 0x95, 0xa0,
0x49, 0x05, 0x97, 0x91, 0xbd, 0x1e, 0x3b, 0xab, 0x3a, 0x3b, 0xab, 0xdd, 0xd9, 0xc4, 0xbe, 0x00,
0x89, 0x3e, 0x01, 0x12, 0x4f, 0xc1, 0x43, 0xc0, 0x75, 0x2f, 0xb9, 0x85, 0x8b, 0x82, 0xc2, 0x8b,
0xa0, 0x73, 0x66, 0xbc, 0xeb, 0x86, 0x22, 0xb5, 0x82, 0x2b, 0xcf, 0x9c, 0xf3, 0x3b, 0x67, 0xce,
0xf9, 0x9d, 0x8f, 0x35, 0xb8, 0x32, 0x4e, 0xdb, 0x71, 0x22, 0x95, 0x64, 0x76, 0x3c, 0x6e, 0x1c,
0xcc, 0x42, 0x75, 0x9e, 0x8d, 0xdb, 0x81, 0xbc, 0x38, 0x9c, 0xc9, 0x99, 0x3c, 0x24, 0xd5, 0x38,
0x9b, 0xd2, 0x8d, 0x2e, 0x74, 0xd2, 0x26, 0xfe, 0xcf, 0x16, 0xd8, 0x27, 0x31, 0x7b, 0x1f, 0xaa,
0x61, 0x14, 0x67, 0x2a, 0xad, 0x5b, 0xcd, 0x52, 0xcb, 0xeb, 0xb8, 0xed, 0x78, 0xdc, 0x1e, 0xa2,
0x84, 0x1b, 0x05, 0x6b, 0x42, 0x59, 0x2c, 0x44, 0x50, 0xb7, 0x9b, 0x56, 0xcb, 0xeb, 0x00, 0x02,
0x06, 0x0b, 0x11, 0x9c, 0xc4, 0xc7, 0x1b, 0x9c, 0x34, 0xec, 0x43, 0xa8, 0xa6, 0x32, 0x4b, 0x02,
0x51, 0x2f, 0x11, 0x66, 0x0b, 0x31, 0xa7, 0x24, 0x21, 0x94, 0xd1, 0xa2, 0xa7, 0x40, 0xc6, 0xcb,
0x7a, 0xb9, 0xf0, 0xd4, 0x93, 0xf1, 0x52, 0x7b, 0x42, 0x0d, 0xbb, 0x0b, 0x95, 0x71, 0x16, 0xce,
0x27, 0xf5, 0x0a, 0x41, 0x3c, 0x84, 0x74, 0x51, 0x40, 0x18, 0xad, 0xeb, 0x96, 0xc1, 0x96, 0xb1,
0xff, 0x2d, 0x54, 0x28, 0x4e, 0xf6, 0x19, 0x54, 0x27, 0xe1, 0x4c, 0xa4, 0xaa, 0x6e, 0x35, 0xad,
0x96, 0xdb, 0xed, 0x3c, 0x7f, 0xb1, 0xb7, 0xf1, 0xdb, 0x8b, 0xbd, 0xfd, 0x35, 0x42, 0x64, 0x2c,
0xa2, 0x40, 0x46, 0x6a, 0x14, 0x46, 0x22, 0x49, 0x0f, 0x67, 0xf2, 0x40, 0x9b, 0xb4, 0xfb, 0xf4,
0xc3, 0x8d, 0x07, 0x76, 0x0f, 0x2a, 0x61, 0x34, 0x11, 0x0b, 0x4a, 0xb6, 0xd4, 0x7d, 0xcb, 0xb8,
0xf2, 0x4e, 0x32, 0x15, 0x67, 0x6a, 0x88, 0x2a, 0xae, 0x11, 0xfe, 0x10, 0xaa, 0x9a, 0x06, 0x76,
0x07, 0xca, 0x17, 0x42, 0x8d, 0xe8, 0x79, 0xaf, 0xe3, 0x60, 0xcc, 0x8f, 0x85, 0x1a, 0x71, 0x92,
0x22, 0xc3, 0x17, 0x32, 0x8b, 0x54, 0x5a, 0xb7, 0x0b, 0x86, 0x1f, 0xa3, 0x84, 0x1b, 0x85, 0xff,
0x0d, 0x94, 0xd1, 0x80, 0x31, 0x28, 0x8f, 0x92, 0x99, 0x2e, 0x85, 0xcb, 0xe9, 0xcc, 0x6a, 0x50,
0x12, 0xd1, 0x25, 0xd9, 0xba, 0x1c, 0x8f, 0x28, 0x09, 0xae, 0x26, 0x44, 0xb5, 0xcb, 0xf1, 0x88,
0x76, 0x59, 0x2a, 0x12, 0xe2, 0xd5, 0xe5, 0x74, 0x66, 0xf7, 0xc0, 0x8d, 0x13, 0xb9, 0x58, 0x9e,
0xa1, 0x75, 0xa5, 0x28, 0xcb, 0x97, 0x28, 0x1c, 0x44, 0x97, 0xdc, 0x89, 0xcd, 0xc9, 0xff, 0xce,
0x86, 0x0a, 0x05, 0xc4, 0x5a, 0x98, 0x7e, 0x9c, 0x69, 0x26, 0x4b, 0x5d, 0x66, 0xd2, 0x07, 0x22,
0x3a, 0xcf, 0x1e, 0x49, 0x6f, 0x80, 0x93, 0x8a, 0xb9, 0x08, 0x94, 0x4c, 0x88, 0x2b, 0x97, 0xe7,
0x77, 0x0c, 0x67, 0x82, 0xe5, 0xd0, 0x11, 0xd2, 0x99, 0xdd, 0x87, 0xaa, 0x24, 0x0e, 0x29, 0xc8,
0x7f, 0x60, 0xd6, 0x40, 0xd0, 0x79, 0x22, 0x46, 0x13, 0x19, 0xcd, 0x97, 0x14, 0xba, 0xc3, 0xf3,
0x3b, 0xbb, 0x0f, 0x2e, 0xb1, 0xf6, 0x64, 0x19, 0x8b, 0x7a, 0xb5, 0x69, 0xb5, 0xb6, 0x3b, 0xb7,
0x72, 0x46, 0x51, 0xc8, 0x0b, 0x3d, 0x6b, 0x81, 0x13, 0x8c, 0x82, 0x73, 0x71, 0x12, 0xab, 0xfa,
0x4e, 0xc1, 0x41, 0xcf, 0xc8, 0x78, 0xae, 0xf5, 0x1b, 0xe0, 0xac, 0xa4, 0x6c, 0x1b, 0xec, 0x61,
0x5f, 0x37, 0x13, 0xb7, 0x87, 0x7d, 0xff, 0x11, 0x54, 0x75, 0x9b, 0xb2, 0x26, 0x94, 0xd2, 0x24,
0x30, 0xa3, 0xb2, 0xbd, 0xea, 0x5f, 0xdd, 0xe9, 0x1c, 0x55, 0x79, 0xee, 0x76, 0x91, 0xbb, 0xcf,
0x01, 0x0a, 0xd8, 0x7f, 0xc3, 0xb1, 0xff, 0x83, 0x05, 0xce, 0x6a, 0xc2, 0xd8, 0x2e, 0x40, 0x38,
0x11, 0x91, 0x0a, 0xa7, 0xa1, 0x48, 0x4c, 0xe0, 0x6b, 0x12, 0x76, 0x00, 0x95, 0x91, 0x52, 0xc9,
0xaa, 0x03, 0xdf, 0x5e, 0x1f, 0xcf, 0xf6, 0x11, 0x6a, 0x06, 0x91, 0x4a, 0x96, 0x5c, 0xa3, 0x1a,
0x0f, 0x01, 0x0a, 0x21, 0xb6, 0xdb, 0x53, 0xb1, 0x34, 0x5e, 0xf1, 0xc8, 0x76, 0xa0, 0x72, 0x39,
0x9a, 0x67, 0xc2, 0x04, 0xa5, 0x2f, 0x9f, 0xda, 0x0f, 0x2d, 0xff, 0x27, 0x1b, 0x36, 0xcd, 0xb8,
0xb2, 0x07, 0xb0, 0x49, 0xe3, 0x6a, 0x22, 0x7a, 0x75, 0xa6, 0x2b, 0x08, 0x3b, 0xcc, 0xf7, 0xd0,
0x5a, 0x8c, 0xc6, 0x95, 0xde, 0x47, 0x26, 0xc6, 0x62, 0x2b, 0x95, 0x26, 0x62, 0x6a, 0x16, 0x0e,
0x95, 0xa2, 0x2f, 0xa6, 0x61, 0x14, 0xaa, 0x50, 0x46, 0x1c, 0x55, 0xec, 0xc1, 0x2a, 0xeb, 0x32,
0x79, 0xbc, 0xbd, 0xee, 0xf1, 0xef, 0x49, 0x0f, 0xc1, 0x5b, 0x7b, 0xe6, 0x15, 0x59, 0x7f, 0xb0,
0x9e, 0xb5, 0x79, 0x92, 0xdc, 0xe9, 0x6d, 0x59, 0xb0, 0xf0, 0x2f, 0xf8, 0xfb, 0x04, 0xa0, 0x70,
0xf9, 0xfa, 0x9d, 0xe2, 0xff, 0x68, 0x03, 0x9c, 0xc4, 0xb8, 0x43, 0x26, 0x23, 0x5a, 0x39, 0x5b,
0xe1, 0x2c, 0x92, 0x89, 0x38, 0xa3, 0xfe, 0x26, 0x7b, 0x87, 0x7b, 0x5a, 0x46, 0x6d, 0xce, 0x8e,
0xc0, 0x9b, 0x88, 0x34, 0x48, 0xc2, 0x18, 0x09, 0x33, 0xa4, 0xef, 0x61, 0x4e, 0x85, 0x9f, 0x76,
0xbf, 0x40, 0x68, 0xae, 0xd6, 0x6d, 0xd8, 0x11, 0xfc, 0xff, 0x4a, 0x26, 0x4f, 0x45, 0x72, 0x16,
0xc8, 0x28, 0x55, 0xc9, 0x28, 0x8c, 0x94, 0xa9, 0xc7, 0x0e, 0x3a, 0xfa, 0x9a, 0x94, 0xbd, 0x5c,
0xc7, 0x6b, 0x57, 0x37, 0x24, 0xac, 0x03, 0x5b, 0x62, 0x11, 0xcb, 0x44, 0x99, 0x40, 0xf5, 0x87,
0xe1, 0x7f, 0xfa, 0x13, 0x83, 0x72, 0x0a, 0x96, 0x7b, 0xa2, 0xb8, 0x34, 0x1e, 0x41, 0xed, 0x66,
0x5c, 0x6f, 0xc4, 0xf1, 0x5d, 0xf0, 0xd6, 0x7c, 0x23, 0xf0, 0x2b, 0x02, 0x6a, 0x92, 0xf4, 0xc5,
0x7f, 0x66, 0x81, 0xb3, 0xda, 0x94, 0xec, 0x3d, 0x80, 0x73, 0xa5, 0xe2, 0x33, 0x5a, 0x98, 0xe6,
0x11, 0x17, 0x25, 0x84, 0x60, 0x7b, 0xe0, 0xe1, 0x25, 0x35, 0x7a, 0xfd, 0x20, 0x59, 0xa4, 0x1a,
0xf0, 0x2e, 0xb8, 0xd3, 0xdc, 0x5c, 0x2f, 0x45, 0x67, 0xba, 0xb2, 0x7e, 0x07, 0x9c, 0x48, 0x1a,
0x9d, 0xde, 0xdf, 0x9b, 0x91, 0x24, 0x95, 0xbf, 0x0f, 0xb5, 0x9b, 0x1c, 0xb2, 0xdb, 0x50, 0x9d,
0x86, 0x73, 0x45, 0x43, 0x85, 0x5f, 0x04, 0x73, 0xf3, 0x7f, 0xb5, 0x00, 0x8a, 0x01, 0x40, 0x42,
0x70, 0x3a, 0x10, 0xb3, 0xa5, 0xa7, 0x61, 0x0e, 0xce, 0x85, 0xa9, 0xab, 0xa9, 0xf6, 0x9d, 0x97,
0x87, 0xa6, 0xbd, 0x2a, 0x3b, 0x51, 0xaa, 0xbf, 0xa2, 0xcf, 0x7e, 0x7f, 0xa3, 0xaf, 0x68, 0xfe,
0x42, 0xe3, 0x73, 0xb8, 0xf5, 0x92, 0xbb, 0xd7, 0x9c, 0xa7, 0xa2, 0xf7, 0xd6, 0x2a, 0xb6, 0xff,
0x31, 0xb8, 0xf9, 0x76, 0x67, 0x0e, 0x94, 0xbb, 0xc3, 0x2f, 0xfa, 0xb5, 0x0d, 0x06, 0x50, 0x3d,
0x1d, 0xf4, 0xf8, 0xe0, 0x49, 0xcd, 0x62, 0x9b, 0x50, 0x3a, 0x3d, 0x3d, 0xae, 0xd9, 0xcc, 0x85,
0x4a, 0xef, 0xa8, 0x77, 0x3c, 0xa8, 0x95, 0xba, 0xb5, 0xe7, 0xd7, 0xbb, 0xd6, 0x2f, 0xd7, 0xbb,
0xd6, 0x1f, 0xd7, 0xbb, 0xd6, 0xf7, 0x7f, 0xee, 0x6e, 0x8c, 0xab, 0xf4, 0xd7, 0xe7, 0xa3, 0xbf,
0x02, 0x00, 0x00, 0xff, 0xff, 0xae, 0x2d, 0xf1, 0xce, 0x3a, 0x09, 0x00, 0x00,
}

10
solver/pb/ops.proto
View File

@ -40,6 +40,7 @@ message Meta {
repeated string env = 2;
string cwd = 3;
string user = 4;
ProxyEnv proxy_env = 5;
}
// Mount specifies how to mount an input Op as a filesystem.
@ -111,7 +112,14 @@ message OpMetadata {
message ExportCache {
bool Value = 1;
};
}
message ProxyEnv {
string http_proxy = 1;
string https_proxy = 2;
string ftp_proxy = 3;
string no_proxy = 4;
}
// WorkerConstraint is experimental and likely to be changed.
message WorkerConstraint {