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

Merge pull request #1640 from ktock/monitor-invoke-mode-restore 

monitor: add `debug-shell` and `on-error`
This commit is contained in:
Justin Chadwell 2023-04-18 10:41:04 +01:00 committed by GitHub
parent b716e48926 fd5d90c699
commit 0b432cc5f2
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
23 changed files with 1124 additions and 316 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
build/build.go
View File

@ -920,7 +920,12 @@ func BuildWithResultHandler(ctx context.Context, nodes []builder.Node, opt map[s
}
results.Set(resultKey(dp.driverIndex, k), res)
if resultHandleFunc != nil {
resultHandleFunc(dp.driverIndex, &ResultContext{cc, res})
resultCtx, err := NewResultContext(cc, so, res)
if err == nil {
resultHandleFunc(dp.driverIndex, resultCtx)
} else {
logrus.Warnf("failed to record result: %s", err)
}
}
return res, nil
}

124
build/invoke.go
View File

@ -3,110 +3,68 @@ package build
import (
"context"
_ "crypto/sha256" // ensure digests can be computed
"encoding/json"
"fmt"
"io"
"sync"
"sync/atomic"
"syscall"
controllerapi "github.com/docker/buildx/controller/pb"
"github.com/moby/buildkit/client"
"github.com/moby/buildkit/exporter/containerimage/exptypes"
gateway "github.com/moby/buildkit/frontend/gateway/client"
"github.com/moby/buildkit/solver/pb"
specs "github.com/opencontainers/image-spec/specs-go/v1"
"github.com/pkg/errors"
"github.com/sirupsen/logrus"
)
// ResultContext is a build result with the client that built it.
type ResultContext struct {
Client *client.Client
Res *gateway.Result
}
type Container struct {
cancelOnce sync.Once
containerCancel func()
isUnavailable atomic.Bool
initStarted atomic.Bool
container gateway.Container
image *specs.Image
releaseCh chan struct{}
isUnavailable atomic.Bool
initStarted atomic.Bool
container gateway.Container
releaseCh chan struct{}
resultCtx *ResultContext
}
func NewContainer(ctx context.Context, resultCtx *ResultContext) (*Container, error) {
c, res := resultCtx.Client, resultCtx.Res
func NewContainer(ctx context.Context, resultCtx *ResultContext, cfg *controllerapi.InvokeConfig) (*Container, error) {
mainCtx := ctx
ctrCh := make(chan *Container)
errCh := make(chan error)
go func() {
_, err := c.Build(context.TODO(), client.SolveOpt{}, "buildx", func(ctx context.Context, c gateway.Client) (*gateway.Result, error) {
err := resultCtx.build(func(ctx context.Context, c gateway.Client) (*gateway.Result, error) {
ctx, cancel := context.WithCancel(ctx)
go func() {
<-mainCtx.Done()
cancel()
}()
if res.Ref == nil {
return nil, errors.Errorf("no reference is registered")
}
st, err := res.Ref.ToState()
if err != nil {
return nil, err
}
def, err := st.Marshal(ctx)
if err != nil {
return nil, err
}
imgRef, err := c.Solve(ctx, gateway.SolveRequest{
Definition: def.ToPB(),
})
containerCfg, err := resultCtx.getContainerConfig(ctx, c, cfg)
if err != nil {
return nil, err
}
containerCtx, containerCancel := context.WithCancel(ctx)
defer containerCancel()
bkContainer, err := c.NewContainer(containerCtx, gateway.NewContainerRequest{
Mounts: []gateway.Mount{
{
Dest: "/",
MountType: pb.MountType_BIND,
Ref: imgRef.Ref,
},
},
})
bkContainer, err := c.NewContainer(containerCtx, containerCfg)
if err != nil {
return nil, err
}
imgData := res.Metadata[exptypes.ExporterImageConfigKey]
var img *specs.Image
if len(imgData) > 0 {
img = &specs.Image{}
if err := json.Unmarshal(imgData, img); err != nil {
fmt.Println(err)
return nil, err
}
}
releaseCh := make(chan struct{})
container := &Container{
containerCancel: containerCancel,
container: bkContainer,
image: img,
releaseCh: releaseCh,
resultCtx: resultCtx,
}
doneCh := make(chan struct{})
defer close(doneCh)
resultCtx.registerCleanup(func() {
container.Cancel()
<-doneCh
})
ctrCh <- container
<-container.releaseCh
return nil, bkContainer.Release(ctx)
}, nil)
})
if err != nil {
errCh <- err
}
@ -146,7 +104,7 @@ func (c *Container) Exec(ctx context.Context, cfg *controllerapi.InvokeConfig, s
c.markUnavailable()
}()
}
err := exec(ctx, cfg, c.container, c.image, stdin, stdout, stderr)
err := exec(ctx, c.resultCtx, cfg, c.container, stdin, stdout, stderr)
if err != nil {
// Container becomes unavailable if one of the processes fails in it.
c.markUnavailable()
@ -154,48 +112,12 @@ func (c *Container) Exec(ctx context.Context, cfg *controllerapi.InvokeConfig, s
return err
}
func exec(ctx context.Context, cfg *controllerapi.InvokeConfig, ctr gateway.Container, img *specs.Image, stdin io.ReadCloser, stdout io.WriteCloser, stderr io.WriteCloser) error {
user := ""
if !cfg.NoUser {
user = cfg.User
} else if img != nil {
user = img.Config.User
func exec(ctx context.Context, resultCtx *ResultContext, cfg *controllerapi.InvokeConfig, ctr gateway.Container, stdin io.ReadCloser, stdout io.WriteCloser, stderr io.WriteCloser) error {
processCfg, err := resultCtx.getProcessConfig(cfg, stdin, stdout, stderr)
if err != nil {
return err
}
cwd := ""
if !cfg.NoCwd {
cwd = cfg.Cwd
} else if img != nil {
cwd = img.Config.WorkingDir
}
env := []string{}
if img != nil {
env = append(env, img.Config.Env...)
}
env = append(env, cfg.Env...)
args := []string{}
if cfg.Entrypoint != nil {
args = append(args, cfg.Entrypoint...)
}
if cfg.Cmd != nil {
args = append(args, cfg.Cmd...)
}
// caller should always set args
if len(args) == 0 {
return errors.Errorf("specify args to execute")
}
proc, err := ctr.Start(ctx, gateway.StartRequest{
Args: args,
Env: env,
User: user,
Cwd: cwd,
Tty: cfg.Tty,
Stdin: stdin,
Stdout: stdout,
Stderr: stderr,
})
proc, err := ctr.Start(ctx, processCfg)
if err != nil {
return errors.Errorf("failed to start container: %v", err)
}

365
build/result.go Normal file
View File

@ -0,0 +1,365 @@
package build
import (
"context"
_ "crypto/sha256" // ensure digests can be computed
"encoding/json"
"io"
"sync"
"sync/atomic"
controllerapi "github.com/docker/buildx/controller/pb"
"github.com/moby/buildkit/client"
"github.com/moby/buildkit/exporter/containerimage/exptypes"
gateway "github.com/moby/buildkit/frontend/gateway/client"
"github.com/moby/buildkit/solver/errdefs"
"github.com/moby/buildkit/solver/pb"
specs "github.com/opencontainers/image-spec/specs-go/v1"
"github.com/pkg/errors"
"github.com/sirupsen/logrus"
)
func NewResultContext(c *client.Client, solveOpt client.SolveOpt, res *gateway.Result) (*ResultContext, error) {
ctx := context.Background()
def, err := getDefinition(ctx, res)
if err != nil {
return nil, err
}
return getResultAt(ctx, c, solveOpt, def, nil)
}
func getDefinition(ctx context.Context, res *gateway.Result) (*pb.Definition, error) {
ref, err := res.SingleRef()
if err != nil {
return nil, err
}
st, err := ref.ToState()
if err != nil {
return nil, err
}
def, err := st.Marshal(ctx)
if err != nil {
return nil, err
}
return def.ToPB(), nil
}
func getResultAt(ctx context.Context, c *client.Client, solveOpt client.SolveOpt, target *pb.Definition, statusChan chan *client.SolveStatus) (*ResultContext, error) {
ctx, cancel := context.WithCancel(ctx)
defer cancel()
// forward SolveStatus
done := new(atomic.Bool)
defer done.Store(true)
ch := make(chan *client.SolveStatus)
go func() {
for {
s := <-ch
if s == nil {
return
}
if done.Load() {
// Do not forward if the function returned because statusChan is possibly closed
continue
}
select {
case statusChan <- s:
case <-ctx.Done():
}
}
}()
// get result
resultCtxCh := make(chan *ResultContext)
errCh := make(chan error)
go func() {
_, err := c.Build(context.Background(), solveOpt, "buildx", func(ctx context.Context, c gateway.Client) (*gateway.Result, error) {
ctx, cancel := context.WithCancel(ctx)
defer cancel()
resultCtx := ResultContext{}
res2, err := c.Solve(ctx, gateway.SolveRequest{
Evaluate: true,
Definition: target,
})
if err != nil {
var se *errdefs.SolveError
if errors.As(err, &se) {
resultCtx.solveErr = se
} else {
return nil, err
}
}
// Record the client and ctx as well so that containers can be created from the SolveError.
resultCtx.res = res2
resultCtx.gwClient = c
resultCtx.gwCtx = ctx
resultCtx.gwDone = cancel
select {
case resultCtxCh <- &resultCtx:
case <-ctx.Done():
return nil, ctx.Err()
}
<-ctx.Done()
return nil, nil
}, ch)
if err != nil {
errCh <- err
}
}()
select {
case resultCtx := <-resultCtxCh:
return resultCtx, nil
case err := <-errCh:
return nil, err
case <-ctx.Done():
return nil, ctx.Err()
}
}
// ResultContext is a build result with the client that built it.
type ResultContext struct {
res *gateway.Result
solveErr *errdefs.SolveError
gwClient gateway.Client
gwCtx context.Context
gwDone func()
gwDoneOnce sync.Once
cleanups []func()
cleanupsMu sync.Mutex
}
func (r *ResultContext) Done() {
r.gwDoneOnce.Do(func() {
r.cleanupsMu.Lock()
cleanups := r.cleanups
r.cleanups = nil
r.cleanupsMu.Unlock()
for _, f := range cleanups {
f()
}
r.gwDone()
})
}
func (r *ResultContext) registerCleanup(f func()) {
r.cleanupsMu.Lock()
r.cleanups = append(r.cleanups, f)
r.cleanupsMu.Unlock()
}
func (r *ResultContext) build(buildFunc gateway.BuildFunc) (err error) {
_, err = buildFunc(r.gwCtx, r.gwClient)
return err
}
func (r *ResultContext) getContainerConfig(ctx context.Context, c gateway.Client, cfg *controllerapi.InvokeConfig) (containerCfg gateway.NewContainerRequest, _ error) {
if r.res != nil && r.solveErr == nil {
logrus.Debugf("creating container from successful build")
ccfg, err := containerConfigFromResult(ctx, r.res, c, *cfg)
if err != nil {
return containerCfg, err
}
containerCfg = *ccfg
} else {
logrus.Debugf("creating container from failed build %+v", cfg)
ccfg, err := containerConfigFromError(r.solveErr, *cfg)
if err != nil {
return containerCfg, errors.Wrapf(err, "no result nor error is available")
}
containerCfg = *ccfg
}
return containerCfg, nil
}
func (r *ResultContext) getProcessConfig(cfg *controllerapi.InvokeConfig, stdin io.ReadCloser, stdout io.WriteCloser, stderr io.WriteCloser) (_ gateway.StartRequest, err error) {
processCfg := newStartRequest(stdin, stdout, stderr)
if r.res != nil && r.solveErr == nil {
logrus.Debugf("creating container from successful build")
if err := populateProcessConfigFromResult(&processCfg, r.res, *cfg); err != nil {
return processCfg, err
}
} else {
logrus.Debugf("creating container from failed build %+v", cfg)
if err := populateProcessConfigFromError(&processCfg, r.solveErr, *cfg); err != nil {
return processCfg, err
}
}
return processCfg, nil
}
func containerConfigFromResult(ctx context.Context, res *gateway.Result, c gateway.Client, cfg controllerapi.InvokeConfig) (*gateway.NewContainerRequest, error) {
if res.Ref == nil {
return nil, errors.Errorf("no reference is registered")
}
if cfg.Initial {
return nil, errors.Errorf("starting from the container from the initial state of the step is supported only on the failed steps")
}
st, err := res.Ref.ToState()
if err != nil {
return nil, err
}
def, err := st.Marshal(ctx)
if err != nil {
return nil, err
}
imgRef, err := c.Solve(ctx, gateway.SolveRequest{
Definition: def.ToPB(),
})
if err != nil {
return nil, err
}
return &gateway.NewContainerRequest{
Mounts: []gateway.Mount{
{
Dest: "/",
MountType: pb.MountType_BIND,
Ref: imgRef.Ref,
},
},
}, nil
}
func populateProcessConfigFromResult(req *gateway.StartRequest, res *gateway.Result, cfg controllerapi.InvokeConfig) error {
imgData := res.Metadata[exptypes.ExporterImageConfigKey]
var img *specs.Image
if len(imgData) > 0 {
img = &specs.Image{}
if err := json.Unmarshal(imgData, img); err != nil {
return err
}
}
user := ""
if !cfg.NoUser {
user = cfg.User
} else if img != nil {
user = img.Config.User
}
cwd := ""
if !cfg.NoCwd {
cwd = cfg.Cwd
} else if img != nil {
cwd = img.Config.WorkingDir
}
env := []string{}
if img != nil {
env = append(env, img.Config.Env...)
}
env = append(env, cfg.Env...)
args := []string{}
if cfg.Entrypoint != nil {
args = append(args, cfg.Entrypoint...)
} else if img != nil {
args = append(args, img.Config.Entrypoint...)
}
if cfg.Cmd != nil {
args = append(args, cfg.Cmd...)
} else if img != nil {
args = append(args, img.Config.Cmd...)
}
req.Args = args
req.Env = env
req.User = user
req.Cwd = cwd
req.Tty = cfg.Tty
return nil
}
func containerConfigFromError(solveErr *errdefs.SolveError, cfg controllerapi.InvokeConfig) (*gateway.NewContainerRequest, error) {
exec, err := execOpFromError(solveErr)
if err != nil {
return nil, err
}
var mounts []gateway.Mount
for i, mnt := range exec.Mounts {
rid := solveErr.Solve.MountIDs[i]
if cfg.Initial {
rid = solveErr.Solve.InputIDs[i]
}
mounts = append(mounts, gateway.Mount{
Selector: mnt.Selector,
Dest: mnt.Dest,
ResultID: rid,
Readonly: mnt.Readonly,
MountType: mnt.MountType,
CacheOpt: mnt.CacheOpt,
SecretOpt: mnt.SecretOpt,
SSHOpt: mnt.SSHOpt,
})
}
return &gateway.NewContainerRequest{
Mounts: mounts,
NetMode: exec.Network,
}, nil
}
func populateProcessConfigFromError(req *gateway.StartRequest, solveErr *errdefs.SolveError, cfg controllerapi.InvokeConfig) error {
exec, err := execOpFromError(solveErr)
if err != nil {
return err
}
meta := exec.Meta
user := ""
if !cfg.NoUser {
user = cfg.User
} else {
user = meta.User
}
cwd := ""
if !cfg.NoCwd {
cwd = cfg.Cwd
} else {
cwd = meta.Cwd
}
env := append(meta.Env, cfg.Env...)
args := []string{}
if cfg.Entrypoint != nil {
args = append(args, cfg.Entrypoint...)
}
if cfg.Cmd != nil {
args = append(args, cfg.Cmd...)
}
if len(args) == 0 {
args = meta.Args
}
req.Args = args
req.Env = env
req.User = user
req.Cwd = cwd
req.Tty = cfg.Tty
return nil
}
func execOpFromError(solveErr *errdefs.SolveError) (*pb.ExecOp, error) {
if solveErr == nil {
return nil, errors.Errorf("no error is available")
}
switch op := solveErr.Solve.Op.GetOp().(type) {
case *pb.Op_Exec:
return op.Exec, nil
default:
return nil, errors.Errorf("invoke: unsupported error type")
}
// TODO: support other ops
}
func newStartRequest(stdin io.ReadCloser, stdout io.WriteCloser, stderr io.WriteCloser) gateway.StartRequest {
return gateway.StartRequest{
Stdin: stdin,
Stdout: stdout,
Stderr: stderr,
}
}

141
commands/build.go
View File

@ -18,6 +18,7 @@ import (
"github.com/docker/buildx/controller"
cbuild "github.com/docker/buildx/controller/build"
"github.com/docker/buildx/controller/control"
controllererrors "github.com/docker/buildx/controller/errdefs"
controllerapi "github.com/docker/buildx/controller/pb"
"github.com/docker/buildx/monitor"
"github.com/docker/buildx/store"
@ -67,7 +68,8 @@ type buildOptions struct {
target string
ulimits *dockeropts.UlimitOpt
invoke string
invoke *invokeConfig
noBuild bool
attests []string
sbom string
@ -229,6 +231,7 @@ func runBuild(dockerCli command.Cli, in buildOptions) error {
func buildCmd(dockerCli command.Cli, rootOpts *rootOptions) *cobra.Command {
options := buildOptions{}
cFlags := &commonFlags{}
var invokeFlag string
cmd := &cobra.Command{
Use: "build [OPTIONS] PATH | URL | -",
@ -250,6 +253,14 @@ func buildCmd(dockerCli command.Cli, rootOpts *rootOptions) *cobra.Command {
options.progress = cFlags.progress
cmd.Flags().VisitAll(checkWarnedFlags)
if isExperimental() {
if invokeFlag != "" {
invokeConfig, err := parseInvokeConfig(invokeFlag)
if err != nil {
return err
}
options.invoke = &invokeConfig
options.noBuild = invokeFlag == "debug-shell"
}
return launchControllerAndRunBuild(dockerCli, options)
}
return runBuild(dockerCli, options)
@ -324,7 +335,7 @@ func buildCmd(dockerCli command.Cli, rootOpts *rootOptions) *cobra.Command {
flags.StringVar(&options.provenance, "provenance", "", `Shortand for "--attest=type=provenance"`)
if isExperimental() {
flags.StringVar(&options.invoke, "invoke", "", "Invoke a command after the build [experimental]")
flags.StringVar(&invokeFlag, "invoke", "", "Invoke a command after the build [experimental]")
flags.StringVar(&options.Root, "root", "", "Specify root directory of server to connect [experimental]")
flags.BoolVar(&options.Detach, "detach", runtime.GOOS == "linux", "Detach buildx server (supported only on linux) [experimental]")
flags.StringVar(&options.ServerConfig, "server-config", "", "Specify buildx server config file (used only when launching new server) [experimental]")
@ -486,18 +497,10 @@ func updateLastActivity(dockerCli command.Cli, ng *store.NodeGroup) error {
func launchControllerAndRunBuild(dockerCli command.Cli, options buildOptions) error {
ctx := context.TODO()
if options.invoke != "" && (options.dockerfileName == "-" || options.contextPath == "-") {
if options.invoke != nil && (options.dockerfileName == "-" || options.contextPath == "-") {
// stdin must be usable for monitor
return errors.Errorf("Dockerfile or context from stdin is not supported with invoke")
}
var invokeConfig controllerapi.InvokeConfig
if inv := options.invoke; inv != "" {
var err error
invokeConfig, err = parseInvokeConfig(inv)
if err != nil {
return err
}
}
c, err := controller.NewController(ctx, options.ControlOptions, dockerCli)
if err != nil {
@ -509,15 +512,7 @@ func launchControllerAndRunBuild(dockerCli command.Cli, options buildOptions) er
}
}()
f := ioset.NewSingleForwarder()
pr, pw := io.Pipe()
f.SetWriter(pw, func() io.WriteCloser {
pw.Close() // propagate EOF
logrus.Debug("propagating stdin close")
return nil
})
f.SetReader(os.Stdin)
// Start build
opts, err := options.toControllerOptions()
if err != nil {
return err
@ -527,14 +522,6 @@ func launchControllerAndRunBuild(dockerCli command.Cli, options buildOptions) er
return err
}
// Avoid leaving a stale file if we eventually fail
if options.imageIDFile != "" {
if err := os.Remove(options.imageIDFile); err != nil && !os.IsNotExist(err) {
return errors.Wrap(err, "removing image ID file")
}
}
// Start build
// NOTE: buildx server has the current working directory different from the client
// so we need to resolve paths to abosolute ones in the client.
optsP, err := resolvePaths(&opts)
@ -542,30 +529,60 @@ func launchControllerAndRunBuild(dockerCli command.Cli, options buildOptions) er
return err
}
opts = *optsP
ref, resp, err := c.Build(ctx, opts, pr, os.Stdout, os.Stderr, progress)
if err != nil {
return errors.Wrapf(err, "failed to build") // TODO: allow invoke even on error
}
if err := pw.Close(); err != nil {
logrus.Debug("failed to close stdin pipe writer")
}
if err := pr.Close(); err != nil {
logrus.Debug("failed to close stdin pipe reader")
}
if options.quiet {
fmt.Println(resp.ExporterResponse[exptypes.ExporterImageDigestKey])
}
if options.imageIDFile != "" {
dgst := resp.ExporterResponse[exptypes.ExporterImageDigestKey]
if v, ok := resp.ExporterResponse[exptypes.ExporterImageConfigDigestKey]; ok {
dgst = v
var ref string
var retErr error
f := ioset.NewSingleForwarder()
f.SetReader(os.Stdin)
if !options.noBuild {
pr, pw := io.Pipe()
f.SetWriter(pw, func() io.WriteCloser {
pw.Close() // propagate EOF
logrus.Debug("propagating stdin close")
return nil
})
// Avoid leaving a stale file if we eventually fail
if options.imageIDFile != "" {
if err := os.Remove(options.imageIDFile); err != nil && !os.IsNotExist(err) {
return errors.Wrap(err, "removing image ID file")
}
}
return os.WriteFile(options.imageIDFile, []byte(dgst), 0644)
var resp *client.SolveResponse
ref, resp, err = c.Build(ctx, opts, pr, os.Stdout, os.Stderr, progress)
if err != nil {
var be *controllererrors.BuildError
if errors.As(err, &be) {
ref = be.Ref
retErr = err
// We can proceed to monitor
} else {
return errors.Wrapf(err, "failed to build")
}
}
if err := pw.Close(); err != nil {
logrus.Debug("failed to close stdin pipe writer")
}
if err := pr.Close(); err != nil {
logrus.Debug("failed to close stdin pipe reader")
}
if options.quiet {
fmt.Println(resp.ExporterResponse[exptypes.ExporterImageDigestKey])
}
if options.imageIDFile != "" {
dgst := resp.ExporterResponse[exptypes.ExporterImageDigestKey]
if v, ok := resp.ExporterResponse[exptypes.ExporterImageConfigDigestKey]; ok {
dgst = v
}
return os.WriteFile(options.imageIDFile, []byte(dgst), 0644)
}
}
// post-build operations
if options.invoke != "" {
if options.invoke != nil && options.invoke.needsMonitor(retErr) {
pr2, pw2 := io.Pipe()
f.SetWriter(pw2, func() io.WriteCloser {
pw2.Close() // propagate EOF
@ -578,7 +595,7 @@ func launchControllerAndRunBuild(dockerCli command.Cli, options buildOptions) er
}
return errors.Errorf("failed to configure terminal: %v", err)
}
err = monitor.RunMonitor(ctx, ref, opts, invokeConfig, c, options.progress, pr2, os.Stdout, os.Stderr)
err = monitor.RunMonitor(ctx, ref, &opts, options.invoke.InvokeConfig, c, progress, pr2, os.Stdout, os.Stderr)
con.Reset()
if err := pw2.Close(); err != nil {
logrus.Debug("failed to close monitor stdin pipe reader")
@ -594,9 +611,33 @@ func launchControllerAndRunBuild(dockerCli command.Cli, options buildOptions) er
return nil
}
func parseInvokeConfig(invoke string) (cfg controllerapi.InvokeConfig, err error) {
type invokeConfig struct {
controllerapi.InvokeConfig
invokeFlag string
}
func (cfg *invokeConfig) needsMonitor(retErr error) bool {
switch cfg.invokeFlag {
case "debug-shell":
return true
case "on-error":
return retErr != nil
default:
return cfg.invokeFlag != ""
}
}
func parseInvokeConfig(invoke string) (cfg invokeConfig, err error) {
cfg.invokeFlag = invoke
cfg.Tty = true
if invoke == "default" {
switch invoke {
case "default", "debug-shell":
return cfg, nil
case "on-error":
// NOTE: we overwrite the command to run because the original one should fail on the failed step.
// TODO: make this configurable via flags or restorable from LLB.
// Discussion: https://github.com/docker/buildx/pull/1640#discussion_r1113295900
cfg.Cmd = []string{"/bin/sh"}
return cfg, nil
}

63
commands/debug-shell.go Normal file
View File

@ -0,0 +1,63 @@
package commands
import (
"context"
"os"
"runtime"
"github.com/containerd/console"
"github.com/docker/buildx/controller"
"github.com/docker/buildx/controller/control"
controllerapi "github.com/docker/buildx/controller/pb"
"github.com/docker/buildx/monitor"
"github.com/docker/cli/cli/command"
"github.com/pkg/errors"
"github.com/sirupsen/logrus"
"github.com/spf13/cobra"
)
func debugShellCmd(dockerCli command.Cli) *cobra.Command {
var options control.ControlOptions
var progress string
cmd := &cobra.Command{
Use: "debug-shell",
Short: "Start a monitor",
RunE: func(cmd *cobra.Command, args []string) error {
ctx := context.TODO()
c, err := controller.NewController(ctx, options, dockerCli)
if err != nil {
return err
}
defer func() {
if err := c.Close(); err != nil {
logrus.Warnf("failed to close server connection %v", err)
}
}()
con := console.Current()
if err := con.SetRaw(); err != nil {
return errors.Errorf("failed to configure terminal: %v", err)
}
err = monitor.RunMonitor(ctx, "", nil, controllerapi.InvokeConfig{
Tty: true,
}, c, progress, os.Stdin, os.Stdout, os.Stderr)
con.Reset()
return err
},
}
flags := cmd.Flags()
flags.StringVar(&options.Root, "root", "", "Specify root directory of server to connect [experimental]")
flags.BoolVar(&options.Detach, "detach", runtime.GOOS == "linux", "Detach buildx server (supported only on linux) [experimental]")
flags.StringVar(&options.ServerConfig, "server-config", "", "Specify buildx server config file (used only when launching new server) [experimental]")
flags.StringVar(&progress, "progress", "auto", `Set type of progress output ("auto", "plain", "tty"). Use plain to show container output`)
return cmd
}
func addDebugShellCommand(cmd *cobra.Command, dockerCli command.Cli) {
cmd.AddCommand(
debugShellCmd(dockerCli),
)
}

1
commands/root.go
View File

@ -89,6 +89,7 @@ func addCommands(cmd *cobra.Command, dockerCli command.Cli) {
)
if isExperimental() {
remote.AddControllerCommands(cmd, dockerCli)
addDebugShellCommand(cmd, dockerCli)
}
}

15
controller/build/build.go
View File

@ -41,6 +41,11 @@ import (
const defaultTargetName = "default"
// RunBuild runs the specified build and returns the result.
//
// NOTE: When an error happens during the build and this function acquires the debuggable *build.ResultContext,
// this function returns it in addition to the error (i.e. it does "return nil, res, err"). The caller can
// inspect the result and debug the cause of that error.
func RunBuild(ctx context.Context, dockerCli command.Cli, in controllerapi.BuildOptions, inStream io.Reader, progressMode string, statusChan chan *client.SolveStatus) (*client.SolveResponse, *build.ResultContext, error) {
if in.NoCache && len(in.NoCacheFilter) > 0 {
return nil, nil, errors.Errorf("--no-cache and --no-cache-filter cannot currently be used together")
@ -177,11 +182,17 @@ func RunBuild(ctx context.Context, dockerCli command.Cli, in controllerapi.Build
resp, res, err := buildTargets(ctx, dockerCli, b.NodeGroup, nodes, map[string]build.Options{defaultTargetName: opts}, progressMode, in.MetadataFile, statusChan)
err = wrapBuildError(err, false)
if err != nil {
return nil, nil, err
// NOTE: buildTargets can return *build.ResultContext even on error.
return nil, res, err
}
return resp, res, nil
}
// buildTargets runs the specified build and returns the result.
//
// NOTE: When an error happens during the build and this function acquires the debuggable *build.ResultContext,
// this function returns it in addition to the error (i.e. it does "return nil, res, err"). The caller can
// inspect the result and debug the cause of that error.
func buildTargets(ctx context.Context, dockerCli command.Cli, ng *store.NodeGroup, nodes []builder.Node, opts map[string]build.Options, progressMode string, metadataFile string, statusChan chan *client.SolveStatus) (*client.SolveResponse, *build.ResultContext, error) {
ctx2, cancel := context.WithCancel(context.TODO())
defer cancel()
@ -209,7 +220,7 @@ func buildTargets(ctx context.Context, dockerCli command.Cli, ng *store.NodeGrou
err = err1
}
if err != nil {
return nil, nil, err
return nil, res, err
}
if len(metadataFile) > 0 && resp != nil {

1
controller/control/controller.go
View File

@ -22,6 +22,7 @@ type BuildxController interface {
Disconnect(ctx context.Context, ref string) error
ListProcesses(ctx context.Context, ref string) (infos []*controllerapi.ProcessInfo, retErr error)
DisconnectProcess(ctx context.Context, ref, pid string) error
Inspect(ctx context.Context, ref string) (*controllerapi.InspectResponse, error)
}
type ControlOptions struct {

34
controller/errdefs/build.go Normal file
View File

@ -0,0 +1,34 @@
package errdefs
import (
"github.com/containerd/typeurl/v2"
"github.com/moby/buildkit/util/grpcerrors"
)
func init() {
typeurl.Register((*Build)(nil), "github.com/docker/buildx", "errdefs.Build+json")
}
type BuildError struct {
Build
error
}
func (e *BuildError) Unwrap() error {
return e.error
}
func (e *BuildError) ToProto() grpcerrors.TypedErrorProto {
return &e.Build
}
func WrapBuild(err error, ref string) error {
if err == nil {
return nil
}
return &BuildError{Build: Build{Ref: ref}, error: err}
}
func (b *Build) WrapError(err error) error {
return &BuildError{error: err, Build: *b}
}

77
controller/errdefs/errdefs.pb.go Normal file
View File

@ -0,0 +1,77 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: errdefs.proto
package errdefs
import (
fmt "fmt"
proto "github.com/gogo/protobuf/proto"
_ "github.com/moby/buildkit/solver/pb"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
type Build struct {
Ref string `protobuf:"bytes,1,opt,name=Ref,proto3" json:"Ref,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Build) Reset() { *m = Build{} }
func (m *Build) String() string { return proto.CompactTextString(m) }
func (*Build) ProtoMessage() {}
func (*Build) Descriptor() ([]byte, []int) {
return fileDescriptor_689dc58a5060aff5, []int{0}
}
func (m *Build) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Build.Unmarshal(m, b)
}
func (m *Build) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Build.Marshal(b, m, deterministic)
}
func (m *Build) XXX_Merge(src proto.Message) {
xxx_messageInfo_Build.Merge(m, src)
}
func (m *Build) XXX_Size() int {
return xxx_messageInfo_Build.Size(m)
}
func (m *Build) XXX_DiscardUnknown() {
xxx_messageInfo_Build.DiscardUnknown(m)
}
var xxx_messageInfo_Build proto.InternalMessageInfo
func (m *Build) GetRef() string {
if m != nil {
return m.Ref
}
return ""
}
func init() {
proto.RegisterType((*Build)(nil), "errdefs.Build")
}
func init() { proto.RegisterFile("errdefs.proto", fileDescriptor_689dc58a5060aff5) }
var fileDescriptor_689dc58a5060aff5 = []byte{
// 111 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x4d, 0x2d, 0x2a, 0x4a,
0x49, 0x4d, 0x2b, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x87, 0x72, 0xa5, 0x74, 0xd2,
0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0x73, 0xf3, 0x93, 0x2a, 0xf5, 0x93,
0x4a, 0x33, 0x73, 0x52, 0xb2, 0x33, 0x4b, 0xf4, 0x8b, 0xf3, 0x73, 0xca, 0x52, 0x8b, 0xf4, 0x0b,
0x92, 0xf4, 0xf3, 0x0b, 0xa0, 0xda, 0x94, 0x24, 0xb9, 0x58, 0x9d, 0x40, 0xf2, 0x42, 0x02, 0x5c,
0xcc, 0x41, 0xa9, 0x69, 0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0x9c, 0x41, 0x20, 0x66, 0x12, 0x1b, 0x58,
0x85, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0x56, 0x52, 0x41, 0x91, 0x69, 0x00, 0x00, 0x00,
}

9
controller/errdefs/errdefs.proto Normal file
View File

@ -0,0 +1,9 @@
syntax = "proto3";
package errdefs;
import "github.com/moby/buildkit/solver/pb/ops.proto";
message Build {
string Ref = 1;
}

3
controller/errdefs/generate.go Normal file
View File

@ -0,0 +1,3 @@
package errdefs
//go:generate protoc -I=. -I=../../vendor/ --gogo_out=plugins=grpc:. errdefs.proto

51
controller/local/controller.go
View File

@ -9,6 +9,7 @@ import (
"github.com/docker/buildx/build"
cbuild "github.com/docker/buildx/controller/build"
"github.com/docker/buildx/controller/control"
controllererrors "github.com/docker/buildx/controller/errdefs"
controllerapi "github.com/docker/buildx/controller/pb"
"github.com/docker/buildx/controller/processes"
"github.com/docker/buildx/util/ioset"
@ -25,11 +26,18 @@ func NewLocalBuildxController(ctx context.Context, dockerCli command.Cli) contro
}
}
type buildConfig struct {
// TODO: these two structs should be merged
// Discussion: https://github.com/docker/buildx/pull/1640#discussion_r1113279719
resultCtx *build.ResultContext
buildOptions *controllerapi.BuildOptions
}
type localController struct {
dockerCli command.Cli
ref string
resultCtx *build.ResultContext
processes *processes.Manager
dockerCli command.Cli
ref string
buildConfig buildConfig
processes *processes.Manager
buildOnGoing atomic.Bool
}
@ -40,11 +48,20 @@ func (b *localController) Build(ctx context.Context, options controllerapi.Build
}
defer b.buildOnGoing.Store(false)
resp, res, err := cbuild.RunBuild(ctx, b.dockerCli, options, in, progressMode, nil)
if err != nil {
return "", nil, err
resp, res, buildErr := cbuild.RunBuild(ctx, b.dockerCli, options, in, progressMode, nil)
// NOTE: RunBuild can return *build.ResultContext even on error.
if res != nil {
b.buildConfig = buildConfig{
resultCtx: res,
buildOptions: &options,
}
if buildErr != nil {
buildErr = controllererrors.WrapBuild(buildErr, b.ref)
}
}
if buildErr != nil {
return "", nil, buildErr
}
b.resultCtx = res
return b.ref, resp, nil
}
@ -74,11 +91,11 @@ func (b *localController) Invoke(ctx context.Context, ref string, pid string, cf
proc, ok := b.processes.Get(pid)
if !ok {
// Start a new process.
if b.resultCtx == nil {
if b.buildConfig.resultCtx == nil {
return errors.New("no build result is registered")
}
var err error
proc, err = b.processes.StartProcess(pid, b.resultCtx, &cfg)
proc, err = b.processes.StartProcess(pid, b.buildConfig.resultCtx, &cfg)
if err != nil {
return err
}
@ -99,12 +116,15 @@ func (b *localController) Invoke(ctx context.Context, ref string, pid string, cf
}
func (b *localController) Kill(context.Context) error {
b.cancelRunningProcesses()
b.Close()
return nil
}
func (b *localController) Close() error {
b.cancelRunningProcesses()
if b.buildConfig.resultCtx != nil {
b.buildConfig.resultCtx.Done()
}
// TODO: cancel ongoing builds?
return nil
}
@ -114,6 +134,13 @@ func (b *localController) List(ctx context.Context) (res []string, _ error) {
}
func (b *localController) Disconnect(ctx context.Context, key string) error {
b.cancelRunningProcesses()
b.Close()
return nil
}
func (b *localController) Inspect(ctx context.Context, ref string) (*controllerapi.InspectResponse, error) {
if ref != b.ref {
return nil, errors.Errorf("unknown ref %q", ref)
}
return &controllerapi.InspectResponse{Options: b.buildConfig.buildOptions}, nil
}

395
controller/pb/controller.pb.go
View File

@ -777,6 +777,82 @@ func (m *Secret) GetEnv() string {
return ""
}
type InspectRequest struct {
Ref string `protobuf:"bytes,1,opt,name=Ref,proto3" json:"Ref,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *InspectRequest) Reset() { *m = InspectRequest{} }
func (m *InspectRequest) String() string { return proto.CompactTextString(m) }
func (*InspectRequest) ProtoMessage() {}
func (*InspectRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_ed7f10298fa1d90f, []int{12}
}
func (m *InspectRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_InspectRequest.Unmarshal(m, b)
}
func (m *InspectRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_InspectRequest.Marshal(b, m, deterministic)
}
func (m *InspectRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_InspectRequest.Merge(m, src)
}
func (m *InspectRequest) XXX_Size() int {
return xxx_messageInfo_InspectRequest.Size(m)
}
func (m *InspectRequest) XXX_DiscardUnknown() {
xxx_messageInfo_InspectRequest.DiscardUnknown(m)
}
var xxx_messageInfo_InspectRequest proto.InternalMessageInfo
func (m *InspectRequest) GetRef() string {
if m != nil {
return m.Ref
}
return ""
}
type InspectResponse struct {
Options *BuildOptions `protobuf:"bytes,1,opt,name=Options,proto3" json:"Options,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *InspectResponse) Reset() { *m = InspectResponse{} }
func (m *InspectResponse) String() string { return proto.CompactTextString(m) }
func (*InspectResponse) ProtoMessage() {}
func (*InspectResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_ed7f10298fa1d90f, []int{13}
}
func (m *InspectResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_InspectResponse.Unmarshal(m, b)
}
func (m *InspectResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_InspectResponse.Marshal(b, m, deterministic)
}
func (m *InspectResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_InspectResponse.Merge(m, src)
}
func (m *InspectResponse) XXX_Size() int {
return xxx_messageInfo_InspectResponse.Size(m)
}
func (m *InspectResponse) XXX_DiscardUnknown() {
xxx_messageInfo_InspectResponse.DiscardUnknown(m)
}
var xxx_messageInfo_InspectResponse proto.InternalMessageInfo
func (m *InspectResponse) GetOptions() *BuildOptions {
if m != nil {
return m.Options
}
return nil
}
type UlimitOpt struct {
Values map[string]*Ulimit `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
@ -788,7 +864,7 @@ func (m *UlimitOpt) Reset() { *m = UlimitOpt{} }
func (m *UlimitOpt) String() string { return proto.CompactTextString(m) }
func (*UlimitOpt) ProtoMessage() {}
func (*UlimitOpt) Descriptor() ([]byte, []int) {
return fileDescriptor_ed7f10298fa1d90f, []int{12}
return fileDescriptor_ed7f10298fa1d90f, []int{14}
}
func (m *UlimitOpt) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UlimitOpt.Unmarshal(m, b)
@ -828,7 +904,7 @@ func (m *Ulimit) Reset() { *m = Ulimit{} }
func (m *Ulimit) String() string { return proto.CompactTextString(m) }
func (*Ulimit) ProtoMessage() {}
func (*Ulimit) Descriptor() ([]byte, []int) {
return fileDescriptor_ed7f10298fa1d90f, []int{13}
return fileDescriptor_ed7f10298fa1d90f, []int{15}
}
func (m *Ulimit) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Ulimit.Unmarshal(m, b)
@ -880,7 +956,7 @@ func (m *BuildResponse) Reset() { *m = BuildResponse{} }
func (m *BuildResponse) String() string { return proto.CompactTextString(m) }
func (*BuildResponse) ProtoMessage() {}
func (*BuildResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_ed7f10298fa1d90f, []int{14}
return fileDescriptor_ed7f10298fa1d90f, []int{16}
}
func (m *BuildResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_BuildResponse.Unmarshal(m, b)
@ -918,7 +994,7 @@ func (m *DisconnectRequest) Reset() { *m = DisconnectRequest{} }
func (m *DisconnectRequest) String() string { return proto.CompactTextString(m) }
func (*DisconnectRequest) ProtoMessage() {}
func (*DisconnectRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_ed7f10298fa1d90f, []int{15}
return fileDescriptor_ed7f10298fa1d90f, []int{17}
}
func (m *DisconnectRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DisconnectRequest.Unmarshal(m, b)
@ -955,7 +1031,7 @@ func (m *DisconnectResponse) Reset() { *m = DisconnectResponse{} }
func (m *DisconnectResponse) String() string { return proto.CompactTextString(m) }
func (*DisconnectResponse) ProtoMessage() {}
func (*DisconnectResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_ed7f10298fa1d90f, []int{16}
return fileDescriptor_ed7f10298fa1d90f, []int{18}
}
func (m *DisconnectResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DisconnectResponse.Unmarshal(m, b)
@ -986,7 +1062,7 @@ func (m *ListRequest) Reset() { *m = ListRequest{} }
func (m *ListRequest) String() string { return proto.CompactTextString(m) }
func (*ListRequest) ProtoMessage() {}
func (*ListRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_ed7f10298fa1d90f, []int{17}
return fileDescriptor_ed7f10298fa1d90f, []int{19}
}
func (m *ListRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListRequest.Unmarshal(m, b)
@ -1024,7 +1100,7 @@ func (m *ListResponse) Reset() { *m = ListResponse{} }
func (m *ListResponse) String() string { return proto.CompactTextString(m) }
func (*ListResponse) ProtoMessage() {}
func (*ListResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_ed7f10298fa1d90f, []int{18}
return fileDescriptor_ed7f10298fa1d90f, []int{20}
}
func (m *ListResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListResponse.Unmarshal(m, b)
@ -1065,7 +1141,7 @@ func (m *InputMessage) Reset() { *m = InputMessage{} }
func (m *InputMessage) String() string { return proto.CompactTextString(m) }
func (*InputMessage) ProtoMessage() {}
func (*InputMessage) Descriptor() ([]byte, []int) {
return fileDescriptor_ed7f10298fa1d90f, []int{19}
return fileDescriptor_ed7f10298fa1d90f, []int{21}
}
func (m *InputMessage) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_InputMessage.Unmarshal(m, b)
@ -1139,7 +1215,7 @@ func (m *InputInitMessage) Reset() { *m = InputInitMessage{} }
func (m *InputInitMessage) String() string { return proto.CompactTextString(m) }
func (*InputInitMessage) ProtoMessage() {}
func (*InputInitMessage) Descriptor() ([]byte, []int) {
return fileDescriptor_ed7f10298fa1d90f, []int{20}
return fileDescriptor_ed7f10298fa1d90f, []int{22}
}
func (m *InputInitMessage) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_InputInitMessage.Unmarshal(m, b)
@ -1178,7 +1254,7 @@ func (m *DataMessage) Reset() { *m = DataMessage{} }
func (m *DataMessage) String() string { return proto.CompactTextString(m) }
func (*DataMessage) ProtoMessage() {}
func (*DataMessage) Descriptor() ([]byte, []int) {
return fileDescriptor_ed7f10298fa1d90f, []int{21}
return fileDescriptor_ed7f10298fa1d90f, []int{23}
}
func (m *DataMessage) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DataMessage.Unmarshal(m, b)
@ -1222,7 +1298,7 @@ func (m *InputResponse) Reset() { *m = InputResponse{} }
func (m *InputResponse) String() string { return proto.CompactTextString(m) }
func (*InputResponse) ProtoMessage() {}
func (*InputResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_ed7f10298fa1d90f, []int{22}
return fileDescriptor_ed7f10298fa1d90f, []int{24}
}
func (m *InputResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_InputResponse.Unmarshal(m, b)
@ -1258,7 +1334,7 @@ func (m *Message) Reset() { *m = Message{} }
func (m *Message) String() string { return proto.CompactTextString(m) }
func (*Message) ProtoMessage() {}
func (*Message) Descriptor() ([]byte, []int) {
return fileDescriptor_ed7f10298fa1d90f, []int{23}
return fileDescriptor_ed7f10298fa1d90f, []int{25}
}
func (m *Message) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Message.Unmarshal(m, b)
@ -1360,7 +1436,7 @@ func (m *InitMessage) Reset() { *m = InitMessage{} }
func (m *InitMessage) String() string { return proto.CompactTextString(m) }
func (*InitMessage) ProtoMessage() {}
func (*InitMessage) Descriptor() ([]byte, []int) {
return fileDescriptor_ed7f10298fa1d90f, []int{24}
return fileDescriptor_ed7f10298fa1d90f, []int{26}
}
func (m *InitMessage) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_InitMessage.Unmarshal(m, b)
@ -1411,6 +1487,7 @@ type InvokeConfig struct {
NoCwd bool `protobuf:"varint,7,opt,name=NoCwd,proto3" json:"NoCwd,omitempty"`
Tty bool `protobuf:"varint,8,opt,name=Tty,proto3" json:"Tty,omitempty"`
Rollback bool `protobuf:"varint,9,opt,name=Rollback,proto3" json:"Rollback,omitempty"`
Initial bool `protobuf:"varint,10,opt,name=Initial,proto3" json:"Initial,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -1420,7 +1497,7 @@ func (m *InvokeConfig) Reset() { *m = InvokeConfig{} }
func (m *InvokeConfig) String() string { return proto.CompactTextString(m) }
func (*InvokeConfig) ProtoMessage() {}
func (*InvokeConfig) Descriptor() ([]byte, []int) {
return fileDescriptor_ed7f10298fa1d90f, []int{25}
return fileDescriptor_ed7f10298fa1d90f, []int{27}
}
func (m *InvokeConfig) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_InvokeConfig.Unmarshal(m, b)
@ -1503,6 +1580,13 @@ func (m *InvokeConfig) GetRollback() bool {
return false
}
func (m *InvokeConfig) GetInitial() bool {
if m != nil {
return m.Initial
}
return false
}
type FdMessage struct {
Fd uint32 `protobuf:"varint,1,opt,name=Fd,proto3" json:"Fd,omitempty"`
EOF bool `protobuf:"varint,2,opt,name=EOF,proto3" json:"EOF,omitempty"`
@ -1516,7 +1600,7 @@ func (m *FdMessage) Reset() { *m = FdMessage{} }
func (m *FdMessage) String() string { return proto.CompactTextString(m) }
func (*FdMessage) ProtoMessage() {}
func (*FdMessage) Descriptor() ([]byte, []int) {
return fileDescriptor_ed7f10298fa1d90f, []int{26}
return fileDescriptor_ed7f10298fa1d90f, []int{28}
}
func (m *FdMessage) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_FdMessage.Unmarshal(m, b)
@ -1569,7 +1653,7 @@ func (m *ResizeMessage) Reset() { *m = ResizeMessage{} }
func (m *ResizeMessage) String() string { return proto.CompactTextString(m) }
func (*ResizeMessage) ProtoMessage() {}
func (*ResizeMessage) Descriptor() ([]byte, []int) {
return fileDescriptor_ed7f10298fa1d90f, []int{27}
return fileDescriptor_ed7f10298fa1d90f, []int{29}
}
func (m *ResizeMessage) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ResizeMessage.Unmarshal(m, b)
@ -1616,7 +1700,7 @@ func (m *SignalMessage) Reset() { *m = SignalMessage{} }
func (m *SignalMessage) String() string { return proto.CompactTextString(m) }
func (*SignalMessage) ProtoMessage() {}
func (*SignalMessage) Descriptor() ([]byte, []int) {
return fileDescriptor_ed7f10298fa1d90f, []int{28}
return fileDescriptor_ed7f10298fa1d90f, []int{30}
}
func (m *SignalMessage) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SignalMessage.Unmarshal(m, b)
@ -1654,7 +1738,7 @@ func (m *StatusRequest) Reset() { *m = StatusRequest{} }
func (m *StatusRequest) String() string { return proto.CompactTextString(m) }
func (*StatusRequest) ProtoMessage() {}
func (*StatusRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_ed7f10298fa1d90f, []int{29}
return fileDescriptor_ed7f10298fa1d90f, []int{31}
}
func (m *StatusRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_StatusRequest.Unmarshal(m, b)
@ -1695,7 +1779,7 @@ func (m *StatusResponse) Reset() { *m = StatusResponse{} }
func (m *StatusResponse) String() string { return proto.CompactTextString(m) }
func (*StatusResponse) ProtoMessage() {}
func (*StatusResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_ed7f10298fa1d90f, []int{30}
return fileDescriptor_ed7f10298fa1d90f, []int{32}
}
func (m *StatusResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_StatusResponse.Unmarshal(m, b)
@ -1753,7 +1837,7 @@ func (m *InfoRequest) Reset() { *m = InfoRequest{} }
func (m *InfoRequest) String() string { return proto.CompactTextString(m) }
func (*InfoRequest) ProtoMessage() {}
func (*InfoRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_ed7f10298fa1d90f, []int{31}
return fileDescriptor_ed7f10298fa1d90f, []int{33}
}
func (m *InfoRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_InfoRequest.Unmarshal(m, b)
@ -1784,7 +1868,7 @@ func (m *InfoResponse) Reset() { *m = InfoResponse{} }
func (m *InfoResponse) String() string { return proto.CompactTextString(m) }
func (*InfoResponse) ProtoMessage() {}
func (*InfoResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_ed7f10298fa1d90f, []int{32}
return fileDescriptor_ed7f10298fa1d90f, []int{34}
}
func (m *InfoResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_InfoResponse.Unmarshal(m, b)
@ -1824,7 +1908,7 @@ func (m *BuildxVersion) Reset() { *m = BuildxVersion{} }
func (m *BuildxVersion) String() string { return proto.CompactTextString(m) }
func (*BuildxVersion) ProtoMessage() {}
func (*BuildxVersion) Descriptor() ([]byte, []int) {
return fileDescriptor_ed7f10298fa1d90f, []int{33}
return fileDescriptor_ed7f10298fa1d90f, []int{35}
}
func (m *BuildxVersion) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_BuildxVersion.Unmarshal(m, b)
@ -1883,6 +1967,8 @@ func init() {
proto.RegisterType((*Attest)(nil), "buildx.controller.v1.Attest")
proto.RegisterType((*SSH)(nil), "buildx.controller.v1.SSH")
proto.RegisterType((*Secret)(nil), "buildx.controller.v1.Secret")
proto.RegisterType((*InspectRequest)(nil), "buildx.controller.v1.InspectRequest")
proto.RegisterType((*InspectResponse)(nil), "buildx.controller.v1.InspectResponse")
proto.RegisterType((*UlimitOpt)(nil), "buildx.controller.v1.UlimitOpt")
proto.RegisterMapType((map[string]*Ulimit)(nil), "buildx.controller.v1.UlimitOpt.ValuesEntry")
proto.RegisterType((*Ulimit)(nil), "buildx.controller.v1.Ulimit")
@ -1912,119 +1998,122 @@ func init() {
func init() { proto.RegisterFile("controller.proto", fileDescriptor_ed7f10298fa1d90f) }
var fileDescriptor_ed7f10298fa1d90f = []byte{
// 1779 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x58, 0x5f, 0x73, 0x1b, 0x49,
0x11, 0x67, 0x25, 0x59, 0x7f, 0x5a, 0x96, 0xcf, 0x19, 0x9c, 0x63, 0xa2, 0x84, 0x8b, 0xb3, 0x09,
0x87, 0x8a, 0x50, 0xf2, 0x9d, 0x8f, 0x23, 0x97, 0x4b, 0xa8, 0xc2, 0x96, 0xad, 0xb2, 0xaf, 0xe2,
0x3f, 0x35, 0x72, 0x72, 0x05, 0x54, 0x91, 0x5a, 0x49, 0x63, 0x79, 0x4b, 0xab, 0x1d, 0xb1, 0x33,
0xb2, 0x2d, 0x9e, 0x78, 0xe1, 0x95, 0xef, 0x41, 0xf1, 0xca, 0x1b, 0x4f, 0x7c, 0x07, 0x3e, 0x08,
0x8f, 0x3c, 0x52, 0xd3, 0x33, 0x2b, 0xad, 0x2c, 0xad, 0x6c, 0xc3, 0x93, 0xa6, 0x7b, 0x7f, 0xbf,
0x9e, 0xe9, 0xde, 0x9e, 0xee, 0x5e, 0xc1, 0x7a, 0x47, 0x84, 0x2a, 0x12, 0x41, 0xc0, 0xa3, 0xfa,
0x30, 0x12, 0x4a, 0x90, 0x8d, 0xf6, 0xc8, 0x0f, 0xba, 0xd7, 0xf5, 0xc4, 0x83, 0xcb, 0x2f, 0xab,
0x6f, 0x7a, 0xbe, 0xba, 0x18, 0xb5, 0xeb, 0x1d, 0x31, 0xd8, 0x1a, 0x88, 0xf6, 0x78, 0x0b, 0x51,
0x7d, 0x5f, 0x6d, 0x79, 0x43, 0x7f, 0x4b, 0xf2, 0xe8, 0xd2, 0xef, 0x70, 0xb9, 0x65, 0x49, 0xf1,
0xaf, 0x31, 0xe9, 0xd6, 0x60, 0xe3, 0x9d, 0x2f, 0xd5, 0x69, 0x24, 0x3a, 0x5c, 0x4a, 0x2e, 0x19,
0xff, 0xc3, 0x88, 0x4b, 0x45, 0xd6, 0x21, 0xcb, 0xf8, 0x39, 0x75, 0x36, 0x9d, 0x5a, 0x89, 0xe9,
0xa5, 0x7b, 0x0a, 0x0f, 0x6f, 0x20, 0xe5, 0x50, 0x84, 0x92, 0x93, 0x57, 0xb0, 0x72, 0x18, 0x9e,
0x0b, 0x49, 0x9d, 0xcd, 0x6c, 0xad, 0xbc, 0xfd, 0xac, 0xbe, 0xe8, 0x94, 0x75, 0xcb, 0xd3, 0x48,
0x66, 0xf0, 0xae, 0x84, 0x72, 0x42, 0x4b, 0x9e, 0x40, 0x29, 0x16, 0xf7, 0xec, 0xc6, 0x53, 0x05,
0x69, 0xc2, 0xea, 0x61, 0x78, 0x29, 0xfa, 0xbc, 0x21, 0xc2, 0x73, 0xbf, 0x47, 0x33, 0x9b, 0x4e,
0xad, 0xbc, 0xed, 0x2e, 0xde, 0x2c, 0x89, 0x64, 0x33, 0x3c, 0xf7, 0x3b, 0xa0, 0x7b, 0xbe, 0xec,
0x88, 0x30, 0xe4, 0x9d, 0xd8, 0x99, 0x54, 0xa7, 0x67, 0xcf, 0x94, 0xb9, 0x71, 0x26, 0xf7, 0x31,
0x3c, 0x5a, 0x60, 0xcb, 0x84, 0xc5, 0xfd, 0x3d, 0xac, 0xee, 0xea, 0xb3, 0xa5, 0x1b, 0x7f, 0x0b,
0x85, 0x93, 0xa1, 0xf2, 0x45, 0x28, 0x97, 0x7b, 0x83, 0x66, 0x2c, 0x92, 0xc5, 0x14, 0xf7, 0x3f,
0x60, 0x37, 0xb0, 0x0a, 0xb2, 0x09, 0xe5, 0x86, 0x08, 0x15, 0xbf, 0x56, 0xa7, 0x9e, 0xba, 0xb0,
0x1b, 0x25, 0x55, 0xe4, 0x73, 0x58, 0xdb, 0x13, 0x9d, 0x3e, 0x8f, 0xce, 0xfd, 0x80, 0x1f, 0x7b,
0x03, 0x6e, 0x5d, 0xba, 0xa1, 0x35, 0x5e, 0xfb, 0xa1, 0x6a, 0x8e, 0xc2, 0x0e, 0xcd, 0xc6, 0x5e,
0x5b, 0x05, 0xf9, 0x1d, 0x54, 0x34, 0xaa, 0x6b, 0x2d, 0x4b, 0x9a, 0xc3, 0xf7, 0xfe, 0xf5, 0xed,
0x87, 0xaf, 0xcf, 0xf0, 0xf6, 0x43, 0x15, 0x8d, 0xd9, 0xac, 0x2d, 0xb2, 0x01, 0x2b, 0x3b, 0x41,
0x20, 0xae, 0xe8, 0xca, 0x66, 0xb6, 0x56, 0x62, 0x46, 0x20, 0xbf, 0x84, 0xc2, 0x8e, 0x52, 0x5c,
0x2a, 0x49, 0xf3, 0xb8, 0xd9, 0x93, 0xc5, 0x9b, 0x19, 0x10, 0x8b, 0xc1, 0xe4, 0x04, 0x4a, 0xb8,
0xff, 0x4e, 0xd4, 0x93, 0xb4, 0x80, 0xcc, 0x2f, 0xef, 0x70, 0xcc, 0x09, 0xc7, 0x1c, 0x71, 0x6a,
0x83, 0xec, 0x43, 0xa9, 0xe1, 0x75, 0x2e, 0x78, 0x33, 0x12, 0x03, 0x5a, 0x44, 0x83, 0x3f, 0x5d,
0x6c, 0x10, 0x61, 0xd6, 0xa0, 0x35, 0x33, 0x61, 0x92, 0x1d, 0x28, 0xa0, 0x70, 0x26, 0x68, 0xe9,
0x7e, 0x46, 0x62, 0x1e, 0x71, 0x61, 0xb5, 0xd1, 0x8b, 0xc4, 0x68, 0x78, 0xea, 0x45, 0x3c, 0x54,
0x14, 0xf0, 0x35, 0xcd, 0xe8, 0xc8, 0x1b, 0x28, 0xec, 0x5f, 0x0f, 0x45, 0xa4, 0x24, 0x2d, 0x2f,
0xbb, 0x9b, 0x06, 0x64, 0x37, 0xb0, 0x0c, 0xf2, 0x19, 0xc0, 0xfe, 0xb5, 0x8a, 0xbc, 0x03, 0xa1,
0xc3, 0xbe, 0x8a, 0xaf, 0x23, 0xa1, 0x21, 0x4d, 0xc8, 0xbf, 0xf3, 0xda, 0x3c, 0x90, 0xb4, 0x82,
0xb6, 0xeb, 0x77, 0x08, 0xac, 0x21, 0x98, 0x8d, 0x2c, 0x5b, 0xa7, 0xed, 0x31, 0x57, 0x57, 0x22,
0xea, 0x1f, 0x89, 0x2e, 0xa7, 0x6b, 0x26, 0x6d, 0x13, 0x2a, 0xf2, 0x02, 0x2a, 0xc7, 0xc2, 0x04,
0xcf, 0x0f, 0x14, 0x8f, 0xe8, 0x27, 0x78, 0x98, 0x59, 0x25, 0x26, 0x6d, 0xe0, 0xa9, 0x73, 0x11,
0x0d, 0x24, 0x5d, 0x47, 0xc4, 0x54, 0xa1, 0x33, 0xa8, 0xc5, 0x3b, 0x11, 0x57, 0x92, 0x3e, 0x58,
0x96, 0x41, 0x06, 0xc4, 0x62, 0x30, 0xa1, 0x50, 0x68, 0x5d, 0x0c, 0x5a, 0xfe, 0x1f, 0x39, 0x25,
0x9b, 0x4e, 0x2d, 0xcb, 0x62, 0x91, 0xbc, 0x84, 0x6c, 0xab, 0x75, 0x40, 0x7f, 0x88, 0xd6, 0x1e,
0xa5, 0x58, 0x6b, 0x1d, 0x30, 0x8d, 0x22, 0x04, 0x72, 0x67, 0x5e, 0x4f, 0xd2, 0x0d, 0x3c, 0x17,
0xae, 0xc9, 0xa7, 0x90, 0x3f, 0xf3, 0xa2, 0x1e, 0x57, 0xf4, 0x21, 0xfa, 0x6c, 0x25, 0xf2, 0x1a,
0x0a, 0xef, 0x03, 0x7f, 0xe0, 0x2b, 0x49, 0x3f, 0xc5, 0xb2, 0xf0, 0x74, 0xb1, 0x71, 0x03, 0x3a,
0x19, 0x2a, 0x16, 0xe3, 0xf5, 0x69, 0x31, 0xde, 0x3c, 0xa2, 0x3f, 0x42, 0x9b, 0xb1, 0xa8, 0xd3,
0xe5, 0x88, 0x2b, 0xaf, 0xeb, 0x29, 0xaf, 0xe9, 0x07, 0x9c, 0x52, 0x93, 0x2e, 0x49, 0x9d, 0x66,
0xdb, 0x90, 0xd2, 0x47, 0x9b, 0x4e, 0xad, 0xc8, 0x62, 0x51, 0x1f, 0xff, 0x74, 0x14, 0x04, 0xb4,
0x8a, 0x6a, 0x5c, 0x9b, 0xfc, 0xd0, 0xa9, 0x72, 0x3a, 0x92, 0x17, 0xf4, 0x31, 0x3e, 0x49, 0x68,
0xa6, 0xcf, 0xdf, 0x09, 0xaf, 0x4b, 0x9f, 0x24, 0x9f, 0x6b, 0x4d, 0xf5, 0xd7, 0x40, 0xe6, 0xcb,
0x81, 0xae, 0x92, 0x7d, 0x3e, 0x8e, 0xab, 0x64, 0x9f, 0x8f, 0x75, 0x45, 0xb8, 0xf4, 0x82, 0x51,
0x5c, 0xab, 0x8c, 0xf0, 0x6d, 0xe6, 0x1b, 0xa7, 0xfa, 0x16, 0xd6, 0x66, 0x6f, 0xea, 0xbd, 0xd8,
0xaf, 0xa1, 0x9c, 0x48, 0xc7, 0xfb, 0x50, 0xdd, 0x7f, 0x3a, 0x50, 0x4e, 0xdc, 0x19, 0x7c, 0xbb,
0xe3, 0x21, 0xb7, 0x64, 0x5c, 0x93, 0x5d, 0x58, 0xd9, 0x51, 0x2a, 0xd2, 0xa5, 0x5d, 0x27, 0xc8,
0xcf, 0x6f, 0xbd, 0x79, 0x75, 0x84, 0x9b, 0xbb, 0x61, 0xa8, 0xfa, 0x6a, 0xec, 0x71, 0xa9, 0xfc,
0xd0, 0xd3, 0xd7, 0xc7, 0x56, 0xe2, 0xa4, 0xaa, 0xfa, 0x0d, 0xc0, 0x94, 0x76, 0x2f, 0x1f, 0xfe,
0xe6, 0xc0, 0x83, 0xb9, 0xf2, 0xb2, 0xd0, 0x93, 0x83, 0x59, 0x4f, 0xb6, 0xef, 0x58, 0xaa, 0xe6,
0xfd, 0xf9, 0x3f, 0x4e, 0x7b, 0x0c, 0x79, 0x53, 0xd3, 0x17, 0x9e, 0xb0, 0x0a, 0xc5, 0x3d, 0x5f,
0x7a, 0xed, 0x80, 0x77, 0x91, 0x5a, 0x64, 0x13, 0x19, 0x1b, 0x0a, 0x9e, 0xde, 0x44, 0xcf, 0x08,
0xae, 0xb9, 0xbc, 0x64, 0x0d, 0x32, 0x93, 0x59, 0x23, 0x73, 0xb8, 0xa7, 0xc1, 0xba, 0x51, 0x1a,
0x57, 0x4b, 0xcc, 0x08, 0x6e, 0x13, 0xf2, 0xa6, 0x1c, 0xcc, 0xe1, 0xab, 0x50, 0xd4, 0x37, 0x07,
0xfb, 0xad, 0x39, 0xf3, 0x44, 0xd6, 0xee, 0xed, 0x87, 0x97, 0x76, 0x5b, 0xbd, 0x74, 0xff, 0xea,
0x40, 0x69, 0x72, 0x69, 0x49, 0x03, 0xf2, 0xe8, 0x5f, 0x3c, 0x37, 0xbd, 0xbc, 0xe5, 0x96, 0xd7,
0x3f, 0x20, 0xda, 0x16, 0x4f, 0x43, 0xad, 0x7e, 0x0f, 0xe5, 0x84, 0x7a, 0x41, 0x48, 0xb7, 0x93,
0x21, 0x4d, 0xad, 0x7a, 0x66, 0x93, 0x64, 0xc0, 0xf7, 0x20, 0x6f, 0x94, 0x3a, 0xe0, 0x38, 0x2a,
0xd8, 0x80, 0xe3, 0x80, 0x40, 0x20, 0x77, 0xe0, 0x45, 0x26, 0xd8, 0x59, 0x86, 0x6b, 0xad, 0x6b,
0x89, 0x73, 0x85, 0x0e, 0x67, 0x19, 0xae, 0xdd, 0x7f, 0x38, 0x50, 0xb1, 0x43, 0x90, 0x1d, 0x16,
0x39, 0xac, 0x9b, 0x9c, 0xe7, 0x51, 0xac, 0xb3, 0xfe, 0xbf, 0x5e, 0xd2, 0x3f, 0x62, 0x68, 0xfd,
0x26, 0xd7, 0x44, 0x63, 0xce, 0x64, 0xb5, 0x01, 0x0f, 0x17, 0x42, 0xef, 0x95, 0x74, 0x3f, 0x81,
0x07, 0xd3, 0xf1, 0x2e, 0x7d, 0x30, 0xde, 0x00, 0x92, 0x84, 0xd9, 0xf1, 0xef, 0x29, 0x94, 0xf5,
0xb8, 0x9c, 0x4e, 0x73, 0x61, 0xd5, 0x00, 0x6c, 0x64, 0x08, 0xe4, 0xfa, 0x7c, 0x6c, 0xb2, 0xa1,
0xc4, 0x70, 0xed, 0xfe, 0xc5, 0xd1, 0x53, 0xef, 0x70, 0xa4, 0x8e, 0xb8, 0x94, 0x5e, 0x8f, 0x93,
0xb7, 0x90, 0x3b, 0x0c, 0x7d, 0x85, 0x76, 0xca, 0xdb, 0x9f, 0xa7, 0x4d, 0xbf, 0xc3, 0x91, 0xd2,
0x30, 0xcb, 0x3a, 0xf8, 0x01, 0x43, 0x16, 0x79, 0x05, 0xb9, 0x3d, 0x4f, 0x79, 0x36, 0x17, 0x52,
0x86, 0x01, 0x8d, 0x48, 0x10, 0xb5, 0xb8, 0x5b, 0xd0, 0x23, 0xfe, 0x70, 0xa4, 0xdc, 0x17, 0xb0,
0x7e, 0xd3, 0xfa, 0x02, 0xd7, 0xbe, 0x82, 0x72, 0xc2, 0x0a, 0xde, 0x84, 0x93, 0x26, 0x02, 0x8a,
0x4c, 0x2f, 0xb5, 0xaf, 0x93, 0x83, 0xac, 0x9a, 0x3d, 0xdc, 0x4f, 0xa0, 0x82, 0xa6, 0x27, 0x11,
0xfc, 0x53, 0x06, 0x0a, 0xb1, 0x89, 0x57, 0x33, 0x7e, 0x3f, 0x4b, 0xf3, 0x7b, 0xde, 0xe5, 0xaf,
0x21, 0x87, 0xfd, 0x2e, 0xb3, 0xac, 0x93, 0x36, 0xbb, 0x09, 0x1a, 0xb6, 0xc2, 0x5f, 0x41, 0x9e,
0x71, 0xa9, 0xbb, 0x7e, 0x16, 0x89, 0xcf, 0x17, 0x13, 0x0d, 0x66, 0x4a, 0xb6, 0x24, 0x4d, 0x6f,
0xf9, 0xbd, 0xd0, 0x0b, 0x68, 0x6e, 0x19, 0xdd, 0x60, 0x12, 0x74, 0xa3, 0x98, 0x86, 0xfb, 0xcf,
0x0e, 0x94, 0x97, 0x86, 0x7a, 0xf9, 0x07, 0xca, 0xdc, 0x47, 0x53, 0xf6, 0x7f, 0xfc, 0x68, 0xfa,
0x97, 0x33, 0x6b, 0x08, 0x9b, 0xbb, 0xbe, 0x4f, 0x43, 0xe1, 0x87, 0xca, 0xa6, 0x6c, 0x42, 0xa3,
0x0f, 0xda, 0x18, 0x74, 0x6d, 0x19, 0xd5, 0xcb, 0x69, 0x39, 0xcc, 0xda, 0x72, 0xa8, 0x93, 0xe0,
0xbd, 0xe4, 0x11, 0x86, 0xa8, 0xc4, 0x70, 0xad, 0x67, 0xa2, 0x63, 0x81, 0xda, 0x15, 0xcc, 0x16,
0x2b, 0xa1, 0xbd, 0xab, 0x2e, 0xcd, 0x1b, 0xc7, 0x1b, 0x57, 0x58, 0xd7, 0x8f, 0x85, 0xd6, 0x15,
0x10, 0x68, 0x04, 0x8d, 0x3b, 0x53, 0x63, 0x5a, 0x34, 0xa9, 0x76, 0xa6, 0xc6, 0xba, 0x44, 0x33,
0x11, 0x04, 0x6d, 0xaf, 0xd3, 0xa7, 0x25, 0xd3, 0x1b, 0x62, 0xd9, 0xdd, 0x81, 0xd2, 0xe4, 0xd5,
0xeb, 0xda, 0xde, 0xec, 0x62, 0x68, 0x2b, 0x2c, 0xd3, 0xec, 0xc6, 0x59, 0x9b, 0x99, 0xcf, 0xda,
0x6c, 0x22, 0x6b, 0x5f, 0x41, 0x65, 0x26, 0x09, 0x34, 0x88, 0x89, 0x2b, 0x69, 0x0d, 0xe1, 0x5a,
0xeb, 0x1a, 0x22, 0x30, 0x5f, 0x79, 0x15, 0x86, 0x6b, 0xf7, 0x39, 0x54, 0x66, 0x5e, 0xff, 0xa2,
0x3a, 0xeb, 0x3e, 0x83, 0x4a, 0x4b, 0x79, 0x6a, 0xb4, 0xe4, 0xb3, 0xfc, 0xdf, 0x0e, 0xac, 0xc5,
0x18, 0x5b, 0x49, 0x7e, 0x01, 0xc5, 0x4b, 0x1e, 0x29, 0x7e, 0x3d, 0xe9, 0x2d, 0xb4, 0x3e, 0x10,
0xed, 0x71, 0x3d, 0xfe, 0x63, 0x40, 0xbf, 0xed, 0x0f, 0x88, 0x60, 0x13, 0x24, 0xf9, 0x16, 0x8a,
0x12, 0xed, 0xf0, 0xb8, 0xd3, 0x7f, 0x96, 0xc6, 0xb2, 0xfb, 0x4d, 0xf0, 0x64, 0x0b, 0x72, 0x81,
0xe8, 0x49, 0x7c, 0xbb, 0xe5, 0xed, 0xc7, 0x69, 0xbc, 0x77, 0xa2, 0xc7, 0x10, 0x48, 0xde, 0x40,
0xf1, 0xca, 0x8b, 0x42, 0x3f, 0xec, 0xc5, 0x9f, 0x8f, 0x4f, 0xd3, 0x48, 0xdf, 0x1b, 0x1c, 0x9b,
0x10, 0xdc, 0x8a, 0xbe, 0x14, 0xe7, 0xc2, 0xc6, 0xc4, 0xfd, 0x8d, 0xce, 0x4d, 0x2d, 0x5a, 0xf7,
0x0f, 0xa1, 0x62, 0xf2, 0xfb, 0x03, 0x8f, 0xa4, 0x9e, 0x9b, 0x9c, 0x65, 0x77, 0x70, 0x37, 0x09,
0x65, 0xb3, 0x4c, 0xf7, 0xa3, 0x6d, 0x5f, 0xb1, 0x42, 0x8f, 0xc8, 0x43, 0xaf, 0xd3, 0xf7, 0x7a,
0xf1, 0x7b, 0x8a, 0x45, 0xfd, 0xe4, 0xd2, 0xee, 0x67, 0xae, 0x61, 0x2c, 0xea, 0x0c, 0x8c, 0xf8,
0xa5, 0x2f, 0xa7, 0x23, 0xdc, 0x44, 0xde, 0xfe, 0x7b, 0x1e, 0xa0, 0x31, 0x39, 0x0f, 0x39, 0x85,
0x15, 0xdc, 0x8f, 0xb8, 0x4b, 0x9b, 0x21, 0xfa, 0x5d, 0x7d, 0x7e, 0x87, 0x86, 0x49, 0xde, 0x43,
0xde, 0xbc, 0x2d, 0x92, 0x56, 0x83, 0x92, 0xf9, 0x55, 0x7d, 0xb1, 0x1c, 0x64, 0x8c, 0x7e, 0xe1,
0x10, 0x66, 0x2b, 0x14, 0x71, 0x97, 0xb4, 0x20, 0x9b, 0xd9, 0x69, 0x07, 0x9d, 0xa9, 0xf6, 0x35,
0x87, 0x7c, 0x07, 0x79, 0x53, 0x63, 0xc8, 0x8f, 0x17, 0x13, 0x62, 0x7b, 0xcb, 0x1f, 0xd7, 0x9c,
0x2f, 0x1c, 0x72, 0x04, 0x39, 0xdd, 0x5c, 0x49, 0x4a, 0xa7, 0x48, 0x74, 0xe6, 0xaa, 0xbb, 0x0c,
0x62, 0xa3, 0xf8, 0x11, 0x60, 0xda, 0xe2, 0x49, 0xca, 0xc7, 0xfa, 0xdc, 0xac, 0x50, 0xad, 0xdd,
0x0e, 0xb4, 0x1b, 0x1c, 0xe9, 0xfe, 0x76, 0x2e, 0x48, 0x6a, 0x67, 0x9b, 0xa4, 0x7b, 0xd5, 0x5d,
0x06, 0xb1, 0xe6, 0x2e, 0xa0, 0x32, 0xf3, 0x5f, 0x1d, 0xf9, 0x59, 0xba, 0x93, 0x37, 0xff, 0xfa,
0xab, 0xbe, 0xbc, 0x13, 0xd6, 0xee, 0xa4, 0x92, 0x33, 0x92, 0x7d, 0x4c, 0xea, 0xb7, 0xf9, 0x3d,
0xfb, 0xbf, 0x5b, 0x75, 0xeb, 0xce, 0x78, 0xb3, 0xeb, 0x6e, 0xee, 0xb7, 0x99, 0x61, 0xbb, 0x9d,
0xc7, 0xbf, 0x30, 0xbf, 0xfa, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf1, 0x90, 0xec, 0x83, 0x29,
0x15, 0x00, 0x00,
// 1832 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x58, 0x5f, 0x6f, 0xdb, 0xc8,
0x11, 0x2f, 0x25, 0x59, 0x7f, 0x46, 0x96, 0xe3, 0x6c, 0x9d, 0xeb, 0x86, 0x49, 0x2f, 0x0e, 0x93,
0xbb, 0x0a, 0x4d, 0x21, 0xdf, 0xf9, 0x7a, 0xcd, 0xe5, 0x72, 0x05, 0x6a, 0xcb, 0x16, 0xec, 0x43,
0xfc, 0x07, 0x94, 0x93, 0x43, 0x5b, 0xa0, 0x07, 0x4a, 0x5a, 0xcb, 0x84, 0x28, 0xae, 0xca, 0x5d,
0xd9, 0x56, 0x9f, 0xfa, 0xd2, 0xb7, 0xa2, 0xdf, 0xa3, 0xe8, 0x47, 0xe8, 0x53, 0xbf, 0x50, 0xd1,
0xc7, 0x3e, 0x16, 0x3b, 0xbb, 0xa4, 0x28, 0x4b, 0x94, 0xed, 0xde, 0x93, 0x76, 0x86, 0xbf, 0xdf,
0xec, 0xce, 0x70, 0x76, 0x66, 0x44, 0x58, 0xef, 0xf2, 0x50, 0x46, 0x3c, 0x08, 0x58, 0xd4, 0x18,
0x45, 0x5c, 0x72, 0xb2, 0xd1, 0x19, 0xfb, 0x41, 0xef, 0xba, 0x91, 0x7a, 0x70, 0xf9, 0xb9, 0xfd,
0xb6, 0xef, 0xcb, 0x8b, 0x71, 0xa7, 0xd1, 0xe5, 0xc3, 0xad, 0x21, 0xef, 0x4c, 0xb6, 0x10, 0x35,
0xf0, 0xe5, 0x96, 0x37, 0xf2, 0xb7, 0x04, 0x8b, 0x2e, 0xfd, 0x2e, 0x13, 0x5b, 0x86, 0x14, 0xff,
0x6a, 0x93, 0x4e, 0x1d, 0x36, 0xde, 0xf9, 0x42, 0x9e, 0x46, 0xbc, 0xcb, 0x84, 0x60, 0xc2, 0x65,
0x7f, 0x1c, 0x33, 0x21, 0xc9, 0x3a, 0xe4, 0x5d, 0x76, 0x4e, 0xad, 0x4d, 0xab, 0x5e, 0x71, 0xd5,
0xd2, 0x39, 0x85, 0x47, 0x37, 0x90, 0x62, 0xc4, 0x43, 0xc1, 0xc8, 0x6b, 0x58, 0x39, 0x0c, 0xcf,
0xb9, 0xa0, 0xd6, 0x66, 0xbe, 0x5e, 0xdd, 0x7e, 0xde, 0x58, 0x74, 0xca, 0x86, 0xe1, 0x29, 0xa4,
0xab, 0xf1, 0x8e, 0x80, 0x6a, 0x4a, 0x4b, 0x9e, 0x42, 0x25, 0x16, 0xf7, 0xcc, 0xc6, 0x53, 0x05,
0x69, 0xc1, 0xea, 0x61, 0x78, 0xc9, 0x07, 0xac, 0xc9, 0xc3, 0x73, 0xbf, 0x4f, 0x73, 0x9b, 0x56,
0xbd, 0xba, 0xed, 0x2c, 0xde, 0x2c, 0x8d, 0x74, 0x67, 0x78, 0xce, 0xb7, 0x40, 0xf7, 0x7c, 0xd1,
0xe5, 0x61, 0xc8, 0xba, 0xb1, 0x33, 0x99, 0x4e, 0xcf, 0x9e, 0x29, 0x77, 0xe3, 0x4c, 0xce, 0x13,
0x78, 0xbc, 0xc0, 0x96, 0x0e, 0x8b, 0xf3, 0x07, 0x58, 0xdd, 0x55, 0x67, 0xcb, 0x36, 0xfe, 0x0d,
0x94, 0x4e, 0x46, 0xd2, 0xe7, 0xa1, 0x58, 0xee, 0x0d, 0x9a, 0x31, 0x48, 0x37, 0xa6, 0x38, 0xff,
0x05, 0xb3, 0x81, 0x51, 0x90, 0x4d, 0xa8, 0x36, 0x79, 0x28, 0xd9, 0xb5, 0x3c, 0xf5, 0xe4, 0x85,
0xd9, 0x28, 0xad, 0x22, 0x9f, 0xc2, 0xda, 0x1e, 0xef, 0x0e, 0x58, 0x74, 0xee, 0x07, 0xec, 0xd8,
0x1b, 0x32, 0xe3, 0xd2, 0x0d, 0xad, 0xf6, 0xda, 0x0f, 0x65, 0x6b, 0x1c, 0x76, 0x69, 0x3e, 0xf6,
0xda, 0x28, 0xc8, 0xef, 0xa1, 0xa6, 0x50, 0x3d, 0x63, 0x59, 0xd0, 0x02, 0xbe, 0xf7, 0x2f, 0x6f,
0x3f, 0x7c, 0x63, 0x86, 0xb7, 0x1f, 0xca, 0x68, 0xe2, 0xce, 0xda, 0x22, 0x1b, 0xb0, 0xb2, 0x13,
0x04, 0xfc, 0x8a, 0xae, 0x6c, 0xe6, 0xeb, 0x15, 0x57, 0x0b, 0xe4, 0x57, 0x50, 0xda, 0x91, 0x92,
0x09, 0x29, 0x68, 0x11, 0x37, 0x7b, 0xba, 0x78, 0x33, 0x0d, 0x72, 0x63, 0x30, 0x39, 0x81, 0x0a,
0xee, 0xbf, 0x13, 0xf5, 0x05, 0x2d, 0x21, 0xf3, 0xf3, 0x3b, 0x1c, 0x33, 0xe1, 0xe8, 0x23, 0x4e,
0x6d, 0x90, 0x7d, 0xa8, 0x34, 0xbd, 0xee, 0x05, 0x6b, 0x45, 0x7c, 0x48, 0xcb, 0x68, 0xf0, 0x67,
0x8b, 0x0d, 0x22, 0xcc, 0x18, 0x34, 0x66, 0x12, 0x26, 0xd9, 0x81, 0x12, 0x0a, 0x67, 0x9c, 0x56,
0xee, 0x67, 0x24, 0xe6, 0x11, 0x07, 0x56, 0x9b, 0xfd, 0x88, 0x8f, 0x47, 0xa7, 0x5e, 0xc4, 0x42,
0x49, 0x01, 0x5f, 0xd3, 0x8c, 0x8e, 0xbc, 0x85, 0xd2, 0xfe, 0xf5, 0x88, 0x47, 0x52, 0xd0, 0xea,
0xb2, 0xbb, 0xa9, 0x41, 0x66, 0x03, 0xc3, 0x20, 0x1f, 0x03, 0xec, 0x5f, 0xcb, 0xc8, 0x3b, 0xe0,
0x2a, 0xec, 0xab, 0xf8, 0x3a, 0x52, 0x1a, 0xd2, 0x82, 0xe2, 0x3b, 0xaf, 0xc3, 0x02, 0x41, 0x6b,
0x68, 0xbb, 0x71, 0x87, 0xc0, 0x6a, 0x82, 0xde, 0xc8, 0xb0, 0x55, 0xda, 0x1e, 0x33, 0x79, 0xc5,
0xa3, 0xc1, 0x11, 0xef, 0x31, 0xba, 0xa6, 0xd3, 0x36, 0xa5, 0x22, 0x2f, 0xa1, 0x76, 0xcc, 0x75,
0xf0, 0xfc, 0x40, 0xb2, 0x88, 0x3e, 0xc0, 0xc3, 0xcc, 0x2a, 0x31, 0x69, 0x03, 0x4f, 0x9e, 0xf3,
0x68, 0x28, 0xe8, 0x3a, 0x22, 0xa6, 0x0a, 0x95, 0x41, 0x6d, 0xd6, 0x8d, 0x98, 0x14, 0xf4, 0xe1,
0xb2, 0x0c, 0xd2, 0x20, 0x37, 0x06, 0x13, 0x0a, 0xa5, 0xf6, 0xc5, 0xb0, 0xed, 0xff, 0x89, 0x51,
0xb2, 0x69, 0xd5, 0xf3, 0x6e, 0x2c, 0x92, 0x57, 0x90, 0x6f, 0xb7, 0x0f, 0xe8, 0x8f, 0xd1, 0xda,
0xe3, 0x0c, 0x6b, 0xed, 0x03, 0x57, 0xa1, 0x08, 0x81, 0xc2, 0x99, 0xd7, 0x17, 0x74, 0x03, 0xcf,
0x85, 0x6b, 0xf2, 0x11, 0x14, 0xcf, 0xbc, 0xa8, 0xcf, 0x24, 0x7d, 0x84, 0x3e, 0x1b, 0x89, 0xbc,
0x81, 0xd2, 0xfb, 0xc0, 0x1f, 0xfa, 0x52, 0xd0, 0x8f, 0xb0, 0x2c, 0x3c, 0x5b, 0x6c, 0x5c, 0x83,
0x4e, 0x46, 0xd2, 0x8d, 0xf1, 0xea, 0xb4, 0x18, 0x6f, 0x16, 0xd1, 0x9f, 0xa0, 0xcd, 0x58, 0x54,
0xe9, 0x72, 0xc4, 0xa4, 0xd7, 0xf3, 0xa4, 0xd7, 0xf2, 0x03, 0x46, 0xa9, 0x4e, 0x97, 0xb4, 0x4e,
0xb1, 0x4d, 0x48, 0xe9, 0xe3, 0x4d, 0xab, 0x5e, 0x76, 0x63, 0x51, 0x1d, 0xff, 0x74, 0x1c, 0x04,
0xd4, 0x46, 0x35, 0xae, 0x75, 0x7e, 0xa8, 0x54, 0x39, 0x1d, 0x8b, 0x0b, 0xfa, 0x04, 0x9f, 0xa4,
0x34, 0xd3, 0xe7, 0xef, 0xb8, 0xd7, 0xa3, 0x4f, 0xd3, 0xcf, 0x95, 0xc6, 0xfe, 0x0d, 0x90, 0xf9,
0x72, 0xa0, 0xaa, 0xe4, 0x80, 0x4d, 0xe2, 0x2a, 0x39, 0x60, 0x13, 0x55, 0x11, 0x2e, 0xbd, 0x60,
0x1c, 0xd7, 0x2a, 0x2d, 0x7c, 0x9d, 0xfb, 0xca, 0xb2, 0xbf, 0x81, 0xb5, 0xd9, 0x9b, 0x7a, 0x2f,
0xf6, 0x1b, 0xa8, 0xa6, 0xd2, 0xf1, 0x3e, 0x54, 0xe7, 0x5f, 0x16, 0x54, 0x53, 0x77, 0x06, 0xdf,
0xee, 0x64, 0xc4, 0x0c, 0x19, 0xd7, 0x64, 0x17, 0x56, 0x76, 0xa4, 0x8c, 0x54, 0x69, 0x57, 0x09,
0xf2, 0x8b, 0x5b, 0x6f, 0x5e, 0x03, 0xe1, 0xfa, 0x6e, 0x68, 0xaa, 0xba, 0x1a, 0x7b, 0x4c, 0x48,
0x3f, 0xf4, 0xd4, 0xf5, 0x31, 0x95, 0x38, 0xad, 0xb2, 0xbf, 0x02, 0x98, 0xd2, 0xee, 0xe5, 0xc3,
0x3f, 0x2c, 0x78, 0x38, 0x57, 0x5e, 0x16, 0x7a, 0x72, 0x30, 0xeb, 0xc9, 0xf6, 0x1d, 0x4b, 0xd5,
0xbc, 0x3f, 0x3f, 0xe0, 0xb4, 0xc7, 0x50, 0xd4, 0x35, 0x7d, 0xe1, 0x09, 0x6d, 0x28, 0xef, 0xf9,
0xc2, 0xeb, 0x04, 0xac, 0x87, 0xd4, 0xb2, 0x9b, 0xc8, 0xd8, 0x50, 0xf0, 0xf4, 0x3a, 0x7a, 0x5a,
0x70, 0xf4, 0xe5, 0x25, 0x6b, 0x90, 0x4b, 0x66, 0x8d, 0xdc, 0xe1, 0x9e, 0x02, 0xab, 0x46, 0xa9,
0x5d, 0xad, 0xb8, 0x5a, 0x70, 0x5a, 0x50, 0xd4, 0xe5, 0x60, 0x0e, 0x6f, 0x43, 0x59, 0xdd, 0x1c,
0xec, 0xb7, 0xfa, 0xcc, 0x89, 0xac, 0xdc, 0xdb, 0x0f, 0x2f, 0xcd, 0xb6, 0x6a, 0xe9, 0x38, 0xb0,
0x76, 0x18, 0x8a, 0x11, 0xeb, 0xca, 0xec, 0x29, 0xeb, 0x04, 0x1e, 0x24, 0x18, 0x33, 0x5f, 0xa5,
0xc6, 0x04, 0xeb, 0xfe, 0x63, 0xc2, 0xdf, 0x2d, 0xa8, 0x24, 0x95, 0x82, 0x34, 0xa1, 0x88, 0x41,
0x8d, 0x87, 0xb5, 0x57, 0xb7, 0x94, 0x96, 0xc6, 0x07, 0x44, 0x9b, 0x8a, 0xad, 0xa9, 0xf6, 0x77,
0x50, 0x4d, 0xa9, 0x17, 0xbc, 0xc7, 0xed, 0xf4, 0x7b, 0xcc, 0x2c, 0xb5, 0x7a, 0x93, 0xf4, 0x5b,
0xde, 0x83, 0xa2, 0x56, 0xaa, 0xb7, 0x8c, 0xf3, 0x89, 0x79, 0xcb, 0x38, 0x95, 0x10, 0x28, 0x1c,
0x78, 0x91, 0x7e, 0xc3, 0x79, 0x17, 0xd7, 0x4a, 0xd7, 0xe6, 0xe7, 0x12, 0xa3, 0x9c, 0x77, 0x71,
0xed, 0xfc, 0xd3, 0x82, 0x9a, 0x99, 0xbc, 0x4c, 0x04, 0x19, 0xac, 0xeb, 0x8b, 0xc6, 0xa2, 0x58,
0x67, 0xfc, 0x7f, 0xb3, 0x24, 0x94, 0x31, 0xb4, 0x71, 0x93, 0xab, 0xa3, 0x31, 0x67, 0xd2, 0x6e,
0xc2, 0xa3, 0x85, 0xd0, 0x7b, 0x65, 0xfa, 0x27, 0xf0, 0x70, 0x3a, 0x53, 0x66, 0xe7, 0xc9, 0x06,
0x90, 0x34, 0xcc, 0xcc, 0x9c, 0xcf, 0xa0, 0xaa, 0x66, 0xf4, 0x6c, 0x9a, 0x03, 0xab, 0x1a, 0x60,
0x22, 0x43, 0xa0, 0x30, 0x60, 0x13, 0x9d, 0x0d, 0x15, 0x17, 0xd7, 0xce, 0xdf, 0x2c, 0x35, 0x6a,
0x8f, 0xc6, 0xf2, 0x88, 0x09, 0xe1, 0xf5, 0x55, 0x02, 0x16, 0x0e, 0x43, 0x5f, 0x9a, 0xec, 0xfb,
0x34, 0x6b, 0xe4, 0x1e, 0x8d, 0xa5, 0x82, 0x19, 0xd6, 0xc1, 0x8f, 0x5c, 0x64, 0x91, 0xd7, 0x50,
0xd8, 0xf3, 0xa4, 0x67, 0x72, 0x21, 0x63, 0x02, 0x51, 0x88, 0x14, 0x51, 0x89, 0xbb, 0x25, 0xf5,
0xbf, 0x62, 0x34, 0x96, 0xce, 0x4b, 0x58, 0xbf, 0x69, 0x7d, 0x81, 0x6b, 0x5f, 0x40, 0x35, 0x65,
0x05, 0xaf, 0xdf, 0x49, 0x0b, 0x01, 0x65, 0x57, 0x2d, 0x95, 0xaf, 0xc9, 0x41, 0x56, 0xf5, 0x1e,
0xce, 0x03, 0xa8, 0xa1, 0xe9, 0x24, 0x82, 0x7f, 0xce, 0x41, 0x29, 0x36, 0xf1, 0x7a, 0xc6, 0xef,
0xe7, 0x59, 0x7e, 0xcf, 0xbb, 0xfc, 0x25, 0x14, 0xb0, 0xc9, 0xe6, 0x96, 0xb5, 0xef, 0x56, 0x2f,
0x45, 0xc3, 0xfe, 0xfb, 0x6b, 0x28, 0xba, 0x4c, 0xa8, 0x51, 0x23, 0x8f, 0xc4, 0x17, 0x8b, 0x89,
0x1a, 0x33, 0x25, 0x1b, 0x92, 0xa2, 0xb7, 0xfd, 0x7e, 0xe8, 0x05, 0xb4, 0xb0, 0x8c, 0xae, 0x31,
0x29, 0xba, 0x56, 0x4c, 0xc3, 0xfd, 0x17, 0x0b, 0xaa, 0x4b, 0x43, 0xbd, 0xfc, 0x5f, 0xd1, 0xdc,
0x3f, 0xb5, 0xfc, 0xff, 0xf9, 0x4f, 0xed, 0xdf, 0xd6, 0xac, 0x21, 0x9c, 0x28, 0xd4, 0x7d, 0x1a,
0x71, 0x3f, 0x94, 0x26, 0x65, 0x53, 0x1a, 0x75, 0xd0, 0xe6, 0xb0, 0x67, 0x6a, 0xb7, 0x5a, 0x4e,
0x6b, 0x70, 0xde, 0xd4, 0x60, 0x95, 0x04, 0xef, 0x05, 0x8b, 0x30, 0x44, 0x15, 0x17, 0xd7, 0x6a,
0x10, 0x3b, 0xe6, 0xa8, 0x5d, 0xc1, 0x6c, 0x31, 0x12, 0xda, 0xbb, 0xea, 0xd1, 0xa2, 0x76, 0xbc,
0x79, 0x85, 0xcd, 0xe4, 0x98, 0x2b, 0x5d, 0x09, 0x81, 0x5a, 0x50, 0xb8, 0x33, 0x39, 0xa1, 0x65,
0x9d, 0x6a, 0x67, 0x72, 0xa2, 0xfa, 0x82, 0xcb, 0x83, 0xa0, 0xe3, 0x75, 0x07, 0xb4, 0xa2, 0x1b,
0x52, 0x2c, 0xab, 0x29, 0x4b, 0x45, 0xd7, 0xf7, 0x02, 0x9c, 0xd9, 0xcb, 0x6e, 0x2c, 0x3a, 0x3b,
0x50, 0x49, 0x92, 0x42, 0xb5, 0x9a, 0x56, 0x0f, 0x83, 0x5e, 0x73, 0x73, 0xad, 0x5e, 0x9c, 0xcf,
0xb9, 0xf9, 0x7c, 0xce, 0xa7, 0xf2, 0xf9, 0x35, 0xd4, 0x66, 0xd2, 0x43, 0x81, 0x5c, 0x7e, 0x25,
0x8c, 0x21, 0x5c, 0x2b, 0x5d, 0x93, 0x07, 0xfa, 0x4f, 0x67, 0xcd, 0xc5, 0xb5, 0xf3, 0x02, 0x6a,
0x33, 0x89, 0xb1, 0xa8, 0x02, 0x3b, 0xcf, 0xa1, 0xd6, 0x96, 0x9e, 0x1c, 0x2f, 0xf9, 0x4a, 0xf0,
0x1f, 0x0b, 0xd6, 0x62, 0x8c, 0xa9, 0x31, 0xbf, 0x84, 0xf2, 0x25, 0x8b, 0x24, 0xbb, 0x4e, 0xba,
0x0e, 0x6d, 0x0c, 0x79, 0x67, 0xd2, 0x88, 0xbf, 0x53, 0xa8, 0x3c, 0xf8, 0x80, 0x08, 0x37, 0x41,
0x92, 0xaf, 0xa1, 0x2c, 0xd0, 0x0e, 0x8b, 0x07, 0x8f, 0x8f, 0xb3, 0x58, 0x66, 0xbf, 0x04, 0x4f,
0xb6, 0xa0, 0x10, 0xf0, 0xbe, 0xc0, 0xf7, 0x5e, 0xdd, 0x7e, 0x92, 0xc5, 0x7b, 0xc7, 0xfb, 0x2e,
0x02, 0xc9, 0x5b, 0x28, 0x5f, 0x79, 0x51, 0xe8, 0x87, 0xfd, 0xf8, 0xdf, 0xec, 0xb3, 0x2c, 0xd2,
0x77, 0x1a, 0xe7, 0x26, 0x04, 0xa7, 0xa6, 0xae, 0xcb, 0x39, 0x37, 0x31, 0x71, 0x7e, 0xab, 0xb2,
0x56, 0x89, 0xc6, 0xfd, 0x43, 0xa8, 0xe9, 0xcc, 0xff, 0xc0, 0x22, 0xa1, 0xc6, 0x38, 0x6b, 0xd9,
0xed, 0xdc, 0x4d, 0x43, 0xdd, 0x59, 0xa6, 0xf3, 0xbd, 0x69, 0x6c, 0xb1, 0x42, 0xe5, 0xd2, 0xc8,
0xeb, 0x0e, 0xbc, 0x7e, 0xfc, 0x9e, 0x62, 0x51, 0x3d, 0xb9, 0x34, 0xfb, 0xe9, 0x0b, 0x1a, 0x8b,
0x2a, 0x37, 0x23, 0x76, 0xe9, 0x8b, 0xe9, 0x44, 0x99, 0xc8, 0xdb, 0x7f, 0x2d, 0x01, 0x34, 0x93,
0xf3, 0x90, 0x53, 0x58, 0xc1, 0xfd, 0x88, 0xb3, 0xb4, 0x4d, 0xa2, 0xdf, 0xf6, 0x8b, 0x3b, 0xb4,
0x52, 0xf2, 0x41, 0x25, 0x3f, 0x8e, 0x37, 0xe4, 0x65, 0x56, 0x41, 0x48, 0x4f, 0x48, 0xf6, 0x27,
0xb7, 0xa0, 0x8c, 0xdd, 0xf7, 0x50, 0xd4, 0x59, 0x40, 0xb2, 0xaa, 0x5e, 0x3a, 0x6f, 0xed, 0x97,
0xcb, 0x41, 0xda, 0xe8, 0x67, 0x16, 0x71, 0x4d, 0x4d, 0x24, 0xce, 0x92, 0xa6, 0x67, 0x6e, 0x4c,
0x56, 0x00, 0x66, 0xfa, 0x4b, 0xdd, 0x22, 0xdf, 0x42, 0x51, 0x57, 0x35, 0xf2, 0xd3, 0xc5, 0x84,
0xd8, 0xde, 0xf2, 0xc7, 0x75, 0xeb, 0x33, 0x8b, 0x1c, 0x41, 0x41, 0xb5, 0x73, 0x92, 0xd1, 0x9b,
0x52, 0xb3, 0x80, 0xed, 0x2c, 0x83, 0x98, 0x28, 0x7e, 0x0f, 0x30, 0x1d, 0x2a, 0x48, 0xc6, 0x37,
0x89, 0xb9, 0xe9, 0xc4, 0xae, 0xdf, 0x0e, 0x34, 0x1b, 0x1c, 0xa9, 0x8e, 0x7a, 0xce, 0x49, 0x66,
0x2f, 0x4d, 0xae, 0x91, 0xed, 0x2c, 0x83, 0x18, 0x73, 0x17, 0x50, 0x9b, 0xf9, 0x24, 0x49, 0x7e,
0x9e, 0xed, 0xe4, 0xcd, 0x2f, 0x9c, 0xf6, 0xab, 0x3b, 0x61, 0xcd, 0x4e, 0x32, 0x3d, 0x95, 0x99,
0xc7, 0xa4, 0x71, 0x9b, 0xdf, 0xb3, 0x9f, 0x17, 0xed, 0xad, 0x3b, 0xe3, 0xf5, 0xae, 0xbb, 0x85,
0xdf, 0xe5, 0x46, 0x9d, 0x4e, 0x11, 0xbf, 0xd4, 0x7e, 0xf1, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff,
0xc2, 0xd5, 0x2b, 0x23, 0x10, 0x16, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -2040,6 +2129,7 @@ const _ = grpc.SupportPackageIsVersion4
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ControllerClient interface {
Build(ctx context.Context, in *BuildRequest, opts ...grpc.CallOption) (*BuildResponse, error)
Inspect(ctx context.Context, in *InspectRequest, opts ...grpc.CallOption) (*InspectResponse, error)
Status(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (Controller_StatusClient, error)
Input(ctx context.Context, opts ...grpc.CallOption) (Controller_InputClient, error)
Invoke(ctx context.Context, opts ...grpc.CallOption) (Controller_InvokeClient, error)
@ -2067,6 +2157,15 @@ func (c *controllerClient) Build(ctx context.Context, in *BuildRequest, opts ...
return out, nil
}
func (c *controllerClient) Inspect(ctx context.Context, in *InspectRequest, opts ...grpc.CallOption) (*InspectResponse, error) {
out := new(InspectResponse)
err := c.cc.Invoke(ctx, "/buildx.controller.v1.Controller/Inspect", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *controllerClient) Status(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (Controller_StatusClient, error) {
stream, err := c.cc.NewStream(ctx, &_Controller_serviceDesc.Streams[0], "/buildx.controller.v1.Controller/Status", opts...)
if err != nil {
@ -2212,6 +2311,7 @@ func (c *controllerClient) DisconnectProcess(ctx context.Context, in *Disconnect
// ControllerServer is the server API for Controller service.
type ControllerServer interface {
Build(context.Context, *BuildRequest) (*BuildResponse, error)
Inspect(context.Context, *InspectRequest) (*InspectResponse, error)
Status(*StatusRequest, Controller_StatusServer) error
Input(Controller_InputServer) error
Invoke(Controller_InvokeServer) error
@ -2229,6 +2329,9 @@ type UnimplementedControllerServer struct {
func (*UnimplementedControllerServer) Build(ctx context.Context, req *BuildRequest) (*BuildResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Build not implemented")
}
func (*UnimplementedControllerServer) Inspect(ctx context.Context, req *InspectRequest) (*InspectResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Inspect not implemented")
}
func (*UnimplementedControllerServer) Status(req *StatusRequest, srv Controller_StatusServer) error {
return status.Errorf(codes.Unimplemented, "method Status not implemented")
}
@ -2276,6 +2379,24 @@ func _Controller_Build_Handler(srv interface{}, ctx context.Context, dec func(in
return interceptor(ctx, in, info, handler)
}
func _Controller_Inspect_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(InspectRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ControllerServer).Inspect(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/buildx.controller.v1.Controller/Inspect",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ControllerServer).Inspect(ctx, req.(*InspectRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Controller_Status_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(StatusRequest)
if err := stream.RecvMsg(m); err != nil {
@ -2447,6 +2568,10 @@ var _Controller_serviceDesc = grpc.ServiceDesc{
MethodName: "Build",
Handler: _Controller_Build_Handler,
},
{
MethodName: "Inspect",
Handler: _Controller_Inspect_Handler,
},
{
MethodName: "List",
Handler: _Controller_List_Handler,

10
controller/pb/controller.proto
View File

@ -8,6 +8,7 @@ option go_package = "pb";
service Controller {
rpc Build(BuildRequest) returns (BuildResponse);
rpc Inspect(InspectRequest) returns (InspectResponse);
rpc Status(StatusRequest) returns (stream StatusResponse);
rpc Input(stream InputMessage) returns (InputResponse);
rpc Invoke(stream Message) returns (stream Message);
@ -105,6 +106,14 @@ message Secret {
string Env = 3;
}
message InspectRequest {
string Ref = 1;
}
message InspectResponse {
BuildOptions Options = 1;
}
message UlimitOpt {
map<string, Ulimit> values = 1;
}
@ -184,6 +193,7 @@ message InvokeConfig {
bool NoCwd = 7; // Do not set cwd but use the image's default
bool Tty = 8;
bool Rollback = 9; // Kill all process in the container and recreate it.
bool Initial = 10; // Run container from the initial state of that stage (supported only on the failed step)
}
message FdMessage {

2
controller/processes/processes.go
View File

@ -111,7 +111,7 @@ func (m *Manager) StartProcess(pid string, resultCtx *build.ResultContext, cfg *
go ctr.Cancel() // Finish the existing container
}
var err error
ctr, err = build.NewContainer(context.TODO(), resultCtx)
ctr, err = build.NewContainer(context.TODO(), resultCtx, cfg)
if err != nil {
return nil, errors.Errorf("failed to create container %v", err)
}

10
controller/remote/client.go
View File

@ -13,6 +13,7 @@ import (
"github.com/docker/buildx/util/progress"
"github.com/moby/buildkit/client"
"github.com/moby/buildkit/identity"
"github.com/moby/buildkit/util/grpcerrors"
"github.com/pkg/errors"
"golang.org/x/sync/errgroup"
"google.golang.org/grpc"
@ -33,6 +34,8 @@ func NewClient(ctx context.Context, addr string) (*Client, error) {
grpc.WithContextDialer(dialer.ContextDialer),
grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(defaults.DefaultMaxRecvMsgSize)),
grpc.WithDefaultCallOptions(grpc.MaxCallSendMsgSize(defaults.DefaultMaxSendMsgSize)),
grpc.WithUnaryInterceptor(grpcerrors.UnaryClientInterceptor),
grpc.WithStreamInterceptor(grpcerrors.StreamClientInterceptor),
}
conn, err := grpc.DialContext(ctx, dialer.DialAddress(addr), gopts...)
if err != nil {
@ -71,6 +74,9 @@ func (c *Client) List(ctx context.Context) (keys []string, retErr error) {
}
func (c *Client) Disconnect(ctx context.Context, key string) error {
if key == "" {
return nil
}
_, err := c.client().Disconnect(ctx, &pb.DisconnectRequest{Ref: key})
return err
}
@ -104,6 +110,10 @@ func (c *Client) Invoke(ctx context.Context, ref string, pid string, invokeConfi
})
}
func (c *Client) Inspect(ctx context.Context, ref string) (*pb.InspectResponse, error) {
return c.client().Inspect(ctx, &pb.InspectRequest{Ref: ref})
}
func (c *Client) Build(ctx context.Context, options pb.BuildOptions, in io.ReadCloser, w io.Writer, out console.File, progressMode string) (string, *client.SolveResponse, error) {
ref := identity.NewID()
pw, err := progress.NewPrinter(context.TODO(), w, out, progressMode)

6
controller/remote/controller.go
View File

@ -24,6 +24,7 @@ import (
"github.com/docker/buildx/version"
"github.com/docker/cli/cli/command"
"github.com/moby/buildkit/client"
"github.com/moby/buildkit/util/grpcerrors"
"github.com/pelletier/go-toml"
"github.com/pkg/errors"
"github.com/sirupsen/logrus"
@ -161,7 +162,10 @@ func serveCmd(dockerCli command.Cli) *cobra.Command {
if err != nil {
return err
}
rpc := grpc.NewServer()
rpc := grpc.NewServer(
grpc.UnaryInterceptor(grpcerrors.UnaryServerInterceptor),
grpc.StreamInterceptor(grpcerrors.StreamServerInterceptor),
)
controllerapi.RegisterControllerServer(rpc, b)
doneCh := make(chan struct{})
errCh := make(chan error, 1)

43
controller/remote/server.go
View File

@ -8,6 +8,7 @@ import (
"time"
"github.com/docker/buildx/build"
controllererrors "github.com/docker/buildx/controller/errdefs"
"github.com/docker/buildx/controller/pb"
"github.com/docker/buildx/controller/processes"
"github.com/docker/buildx/util/ioset"
@ -36,6 +37,7 @@ type session struct {
buildOnGoing atomic.Bool
statusChan chan *client.SolveStatus
cancelBuild func()
buildOptions *pb.BuildOptions
inputPipe *io.PipeWriter
result *build.ResultContext
@ -111,6 +113,9 @@ func (m *Server) Disconnect(ctx context.Context, req *pb.DisconnectRequest) (res
s.cancelBuild()
}
s.cancelRunningProcesses()
if s.result != nil {
s.result.Done()
}
}
delete(m.session, key)
m.sessionMu.Unlock()
@ -132,6 +137,23 @@ func (m *Server) Close() error {
return nil
}
func (m *Server) Inspect(ctx context.Context, req *pb.InspectRequest) (*pb.InspectResponse, error) {
ref := req.Ref
if ref == "" {
return nil, errors.New("inspect: empty key")
}
var bo *pb.BuildOptions
m.sessionMu.Lock()
if s, ok := m.session[ref]; ok {
bo = s.buildOptions
} else {
m.sessionMu.Unlock()
return nil, errors.Errorf("inspect: unknown key %v", ref)
}
m.sessionMu.Unlock()
return &pb.InspectResponse{Options: bo}, nil
}
func (m *Server) Build(ctx context.Context, req *pb.BuildRequest) (*pb.BuildResponse, error) {
ref := req.Ref
if ref == "" {
@ -177,24 +199,35 @@ func (m *Server) Build(ctx context.Context, req *pb.BuildRequest) (*pb.BuildResp
// Build the specified request
ctx, cancel := context.WithCancel(ctx)
defer cancel()
resp, res, err := m.buildFunc(ctx, req.Options, inR, statusChan)
resp, res, buildErr := m.buildFunc(ctx, req.Options, inR, statusChan)
m.sessionMu.Lock()
if s, ok := m.session[ref]; ok {
s.result = res
s.cancelBuild = cancel
m.session[ref] = s
// NOTE: buildFunc can return *build.ResultContext even on error (e.g. when it's implemented using (github.com/docker/buildx/controller/build).RunBuild).
if res != nil {
s.result = res
s.cancelBuild = cancel
s.buildOptions = req.Options
m.session[ref] = s
if buildErr != nil {
buildErr = controllererrors.WrapBuild(buildErr, ref)
}
}
} else {
m.sessionMu.Unlock()
return nil, errors.Errorf("build: unknown key %v", ref)
}
m.sessionMu.Unlock()
if buildErr != nil {
return nil, buildErr
}
if resp == nil {
resp = &client.SolveResponse{}
}
return &pb.BuildResponse{
ExporterResponse: resp.ExporterResponse,
}, err
}, nil
}
func (m *Server) Status(req *pb.StatusRequest, stream pb.Controller_StatusServer) error {

1
docs/reference/buildx.md
View File

@ -15,6 +15,7 @@ Extended build capabilities with BuildKit
| [`bake`](buildx_bake.md) | Build from a file |
| [`build`](buildx_build.md) | Start a build |
| [`create`](buildx_create.md) | Create a new builder instance |
| [`debug-shell`](buildx_debug-shell.md) | Start a monitor |
| [`du`](buildx_du.md) | Disk usage |
| [`imagetools`](buildx_imagetools.md) | Commands to work on images in registry |
| [`inspect`](buildx_inspect.md) | Inspect current builder instance |

18
docs/reference/buildx_debug-shell.md Normal file
View File

@ -0,0 +1,18 @@
# docker buildx debug-shell
<!---MARKER_GEN_START-->
Start a monitor
### Options
| Name | Type | Default | Description |
|:------------------|:---------|:--------|:-----------------------------------------------------------------------------------------|
| `--builder` | `string` | | Override the configured builder instance |
| `--detach` | | | Detach buildx server (supported only on linux) [experimental] |
| `--progress` | `string` | `auto` | Set type of progress output (`auto`, `plain`, `tty`). Use plain to show container output |
| `--root` | `string` | | Specify root directory of server to connect [experimental] |
| `--server-config` | `string` | | Specify buildx server config file (used only when launching new server) [experimental] |
<!---MARKER_GEN_END-->

2
go.mod
View File

@ -8,6 +8,7 @@ require (
github.com/compose-spec/compose-go v1.9.0
github.com/containerd/console v1.0.3
github.com/containerd/containerd v1.7.0
github.com/containerd/typeurl/v2 v2.1.0
github.com/docker/cli v23.0.1+incompatible
github.com/docker/cli-docs-tool v0.5.1
github.com/docker/distribution v2.8.1+incompatible
@ -82,7 +83,6 @@ require (
github.com/cloudflare/cfssl v0.0.0-20181213083726-b94e044bb51e // indirect
github.com/containerd/continuity v0.3.0 // indirect
github.com/containerd/ttrpc v1.2.1 // indirect
github.com/containerd/typeurl/v2 v2.1.0 // indirect
github.com/cyphar/filepath-securejoin v0.2.3 // indirect
github.com/davecgh/go-spew v1.1.1 // indirect
github.com/distribution/distribution/v3 v3.0.0-20221103125252-ebfa2a0ac0a9 // indirect

62
monitor/monitor.go
View File

@ -12,6 +12,7 @@ import (
"github.com/containerd/console"
"github.com/docker/buildx/controller/control"
controllererrors "github.com/docker/buildx/controller/errdefs"
controllerapi "github.com/docker/buildx/controller/pb"
"github.com/docker/buildx/util/ioset"
"github.com/moby/buildkit/identity"
@ -35,7 +36,7 @@ Available commands are:
`
// RunMonitor provides an interactive session for running and managing containers via specified IO.
func RunMonitor(ctx context.Context, curRef string, options controllerapi.BuildOptions, invokeConfig controllerapi.InvokeConfig, c control.BuildxController, progressMode string, stdin io.ReadCloser, stdout io.WriteCloser, stderr console.File) error {
func RunMonitor(ctx context.Context, curRef string, options *controllerapi.BuildOptions, invokeConfig controllerapi.InvokeConfig, c control.BuildxController, progressMode string, stdin io.ReadCloser, stdout io.WriteCloser, stderr console.File) error {
defer func() {
if err := c.Disconnect(ctx, curRef); err != nil {
logrus.Warnf("disconnect error: %v", err)
@ -84,6 +85,8 @@ func RunMonitor(ctx context.Context, curRef string, options controllerapi.BuildO
// Start container automatically
fmt.Fprintf(stdout, "Launching interactive container. Press Ctrl-a-c to switch to monitor console\n")
invokeConfig.Rollback = false
invokeConfig.Initial = false
id := m.rollback(ctx, curRef, invokeConfig)
fmt.Fprintf(stdout, "Interactive container was restarted with process %q. Press Ctrl-a-c to switch to the new container\n", id)
@ -120,16 +123,42 @@ func RunMonitor(ctx context.Context, curRef string, options controllerapi.BuildO
case "":
// nop
case "reload":
var bo *controllerapi.BuildOptions
if curRef != "" {
// Rebuilding an existing session; Restore the build option used for building this session.
res, err := c.Inspect(ctx, curRef)
if err != nil {
fmt.Printf("failed to inspect the current build session: %v\n", err)
} else {
bo = res.Options
}
} else {
bo = options
}
if bo == nil {
fmt.Println("reload: no build option is provided")
continue
}
if curRef != "" {
if err := c.Disconnect(ctx, curRef); err != nil {
fmt.Println("disconnect error", err)
}
}
ref, _, err := c.Build(ctx, options, nil, stdout, stderr, progressMode) // TODO: support stdin, hold build ref
var resultUpdated bool
ref, _, err := c.Build(ctx, *bo, nil, stdout, stderr, progressMode) // TODO: support stdin, hold build ref
if err != nil {
fmt.Printf("failed to reload: %v\n", err)
var be *controllererrors.BuildError
if errors.As(err, &be) {
curRef = be.Ref
resultUpdated = true
} else {
fmt.Printf("failed to reload: %v\n", err)
}
} else {
curRef = ref
resultUpdated = true
}
if resultUpdated {
// rollback the running container with the new result
id := m.rollback(ctx, curRef, invokeConfig)
fmt.Fprintf(stdout, "Interactive container was restarted with process %q. Press Ctrl-a-c to switch to the new container\n", id)
@ -137,8 +166,15 @@ func RunMonitor(ctx context.Context, curRef string, options controllerapi.BuildO
case "rollback":
cfg := invokeConfig
if len(args) >= 2 {
cfg.Entrypoint = []string{args[1]}
cfg.Cmd = args[2:]
cmds := args[1:]
if cmds[0] == "--init" {
cfg.Initial = true
cmds = cmds[1:]
}
if len(cmds) > 0 {
cfg.Entrypoint = []string{cmds[0]}
cfg.Cmd = cmds[1:]
}
}
id := m.rollback(ctx, curRef, cfg)
fmt.Fprintf(stdout, "Interactive container was restarted with process %q. Press Ctrl-a-c to switch to the new container\n", id)
@ -254,10 +290,10 @@ func RunMonitor(ctx context.Context, curRef string, options controllerapi.BuildO
}()
select {
case <-doneCh:
m.invokeCancel()
m.close()
return nil
case err := <-errCh:
m.invokeCancel()
m.close()
return err
case <-monitorDisableCh:
}
@ -293,10 +329,19 @@ func (m *monitor) attach(ctx context.Context, ref, pid string) {
m.startInvoke(ctx, ref, pid, controllerapi.InvokeConfig{})
}
func (m *monitor) close() {
if m.invokeCancel != nil {
m.invokeCancel()
}
}
func (m *monitor) startInvoke(ctx context.Context, ref, pid string, cfg controllerapi.InvokeConfig) string {
if m.invokeCancel != nil {
m.invokeCancel() // Finish existing attach
}
if len(cfg.Entrypoint) == 0 && len(cfg.Cmd) == 0 {
cfg.Entrypoint = []string{"sh"} // launch shell by default
}
go func() {
// Start a new invoke
if err := m.invoke(ctx, ref, pid, cfg); err != nil {
@ -316,6 +361,9 @@ func (m *monitor) invoke(ctx context.Context, ref, pid string, cfg controllerapi
if err := m.muxIO.SwitchTo(1); err != nil {
return errors.Errorf("failed to switch to process IO: %v", err)
}
if ref == "" {
return nil
}
invokeCtx, invokeCancel := context.WithCancel(ctx)
containerIn, containerOut := ioset.Pipe()