examples: demonstrate client-side Build() interface.

This is a clone-and-hack of `examples/build-using-dockerfile` which uses the
new `Build()` client method and thus runs as a clientside-frontend.

Signed-off-by: Ian Campbell <ijc@docker.com>

examples/build-using-dockerfile-client-gateway/main.go

@@ -0,0 +1,160 @@
+package main
+
+import (
+ "context"
+ "fmt"
+ "io"
+ "os"
+ "os/exec"
+ "path/filepath"
+ "strings"
+
+ "github.com/containerd/console"
+ "github.com/moby/buildkit/client"
+ dockerfile "github.com/moby/buildkit/frontend/dockerfile/builder"
+ "github.com/moby/buildkit/util/appcontext"
+ "github.com/moby/buildkit/util/appdefaults"
+ "github.com/moby/buildkit/util/progress/progressui"
+ "github.com/pkg/errors"
+ "github.com/sirupsen/logrus"
+ "github.com/urfave/cli"
+ "golang.org/x/sync/errgroup"
+)
+
+func main() {
+ app := cli.NewApp()
+ app.Name = "build-using-dockerfile"
+ app.UsageText = `build-using-dockerfile [OPTIONS] PATH | URL | -`
+ app.Description = `
+build using Dockerfile.
+
+This command mimics behavior of "docker build" command so that people can easily get started with BuildKit.
+This command is NOT the replacement of "docker build", and should NOT be used for building production images.
+
+By default, the built image is loaded to Docker.
+`
+ dockerIncompatibleFlags := []cli.Flag{
+ cli.StringFlag{
+ Name: "buildkit-addr",
+ Usage: "buildkit daemon address",
+ EnvVar: "BUILDKIT_HOST",
+ Value: appdefaults.Address,
+ },
+ }
+ app.Flags = append([]cli.Flag{
+ cli.StringSliceFlag{
+ Name: "build-arg",
+ Usage: "Set build-time variables",
+ },
+ cli.StringFlag{
+ Name: "file, f",
+ Usage: "Name of the Dockerfile (Default is 'PATH/Dockerfile')",
+ },
+ cli.StringFlag{
+ Name: "tag, t",
+ Usage: "Name and optionally a tag in the 'name:tag' format",
+ },
+ cli.StringFlag{
+ Name: "target",
+ Usage: "Set the target build stage to build.",
+ },
+ }, dockerIncompatibleFlags...)
+ app.Action = action
+ if err := app.Run(os.Args); err != nil {
+ fmt.Fprintf(os.Stderr, "error: %v\n", err)
+ os.Exit(1)
+ }
+}
+
+func action(clicontext *cli.Context) error {
+ ctx := appcontext.Context()
+
+ if tag := clicontext.String("tag"); tag == "" {
+ return errors.New("tag is not specified")
+ }
+ c, err := client.New(ctx, clicontext.String("buildkit-addr"), client.WithBlock())
+ if err != nil {
+ return err
+ }
+ pipeR, pipeW := io.Pipe()
+ buildOpt, err := newSolveOpt(clicontext, pipeW)
+ if err != nil {
+ return err
+ }
+ ch := make(chan *client.SolveStatus)
+ eg, ctx := errgroup.WithContext(ctx)
+ eg.Go(func() error {
+ _, err := c.Build(ctx, *buildOpt, "", dockerfile.Build, ch)
+ return err
+ })
+ eg.Go(func() error {
+ var c console.Console
+ if cn, err := console.ConsoleFromFile(os.Stderr); err == nil {
+ c = cn
+ }
+ // not using shared context to not disrupt display but let is finish reporting errors
+ return progressui.DisplaySolveStatus(context.TODO(), c, os.Stdout, ch)
+ })
+ eg.Go(func() error {
+ if err := loadDockerTar(pipeR); err != nil {
+ return err
+ }
+ return pipeR.Close()
+ })
+ if err := eg.Wait(); err != nil {
+ return err
+ }
+ logrus.Infof("Loaded the image %q to Docker.", clicontext.String("tag"))
+ return nil
+}
+
+func newSolveOpt(clicontext *cli.Context, w io.WriteCloser) (*client.SolveOpt, error) {
+ buildCtx := clicontext.Args().First()
+ if buildCtx == "" {
+ return nil, errors.New("please specify build context (e.g. \".\" for the current directory)")
+ } else if buildCtx == "-" {
+ return nil, errors.New("stdin not supported yet")
+ }
+
+ file := clicontext.String("file")
+ if file == "" {
+ file = filepath.Join(buildCtx, "Dockerfile")
+ }
+ localDirs := map[string]string{
+ "context": buildCtx,
+ "dockerfile": filepath.Dir(file),
+ }
+
+ frontendAttrs := map[string]string{
+ "filename": filepath.Base(file),
+ }
+ if target := clicontext.String("target"); target != "" {
+ frontendAttrs["target"] = target
+ }
+
+ for _, buildArg := range clicontext.StringSlice("build-arg") {
+ kv := strings.SplitN(buildArg, "=", 2)
+ if len(kv) != 2 {
+ return nil, errors.Errorf("invalid build-arg value %s", buildArg)
+ }
+ frontendAttrs["build-arg:"+kv[0]] = kv[1]
+ }
+ return &client.SolveOpt{
+ Exporter: "docker", // TODO: use containerd image store when it is integrated to Docker
+ ExporterAttrs: map[string]string{
+ "name": clicontext.String("tag"),
+ },
+ ExporterOutput: w,
+ LocalDirs: localDirs,
+ FrontendAttrs: frontendAttrs,
+ }, nil
+}
+
+func loadDockerTar(r io.Reader) error {
+ // no need to use moby/moby/client here
+ cmd := exec.Command("docker", "load")
+ cmd.Stdin = r
+ cmd.Stdout = os.Stdout
+ cmd.Stderr = os.Stderr
+ return cmd.Run()
+}