Adjust the "docker app build" UX

docker app build -f <path to x.dockerapp folder> <path to docker context, typically ".">

Signed-off-by: Nicolas De Loof <nicolas.deloof@gmail.com>

Author: ndeloof

e2e/build_test.go

@@ -17,7 +17,7 @@ func TestBuild(t *testing.T) {
 		cmd := info.configuredCmd
 
 		testDir := path.Join("testdata", "build")
-		cmd.Command = dockerCli.Command("app", "build", path.Join(testDir, "single"), "--tag", "single:1.0.0")
+		cmd.Command = dockerCli.Command("app", "build", "--tag", "single:1.0.0", "-f", path.Join(testDir, "single.dockerapp"), testDir)
 		icmd.RunCmd(cmd).Assert(t, icmd.Success)
 
 		cfg := getDockerConfigDir(t, cmd)
@@ -42,7 +42,7 @@ func TestBuildWithoutTag(t *testing.T) {
 		cmd := info.configuredCmd
 
 		testDir := path.Join("testdata", "build")
-		cmd.Command = dockerCli.Command("app", "build", path.Join(testDir, "single"))
+		cmd.Command = dockerCli.Command("app", "build", "-f", path.Join(testDir, "single.dockerapp"), testDir)
 		icmd.RunCmd(cmd).Assert(t, icmd.Success)
 
 		cfg := getDockerConfigDir(t, cmd)

e2e/commands_test.go

@@ -74,8 +74,9 @@ func TestRenderFormatters(t *testing.T) {
 	runWithDindSwarmAndRegistry(t, func(info dindSwarmAndRegistryInfo) {
 		cmd := info.configuredCmd
 
-		appPath := filepath.Join("testdata", "simple", "simple.dockerapp")
-		cmd.Command = dockerCli.Command("app", "build", appPath, "--tag", "a-simple-tag")
+		contextPath := filepath.Join("testdata", "simple")
+		appPath := filepath.Join(contextPath, "simple.dockerapp")
+		cmd.Command = dockerCli.Command("app", "build", "--tag", "a-simple-tag", contextPath)
 		icmd.RunCmd(cmd).Assert(t, icmd.Success)
 
 		cmd.Command = dockerCli.Command("app", "render", "--formatter", "json", appPath)
@@ -164,7 +165,8 @@ func TestInspectApp(t *testing.T) {
 			Err:      `"docker app inspect" requires exactly 1 argument.`,
 		})
 
-		cmd.Command = dockerCli.Command("app", "build", filepath.Join("testdata", "simple", "simple.dockerapp"), "--tag", "simple-app:1.0.0")
+		contextPath := filepath.Join("testdata", "simple")
+		cmd.Command = dockerCli.Command("app", "build", "--tag", "simple-app:1.0.0", contextPath)
 		cmd.Dir = ""
 		icmd.RunCmd(cmd).Assert(t, icmd.Success)
 

e2e/images_test.go

@@ -12,11 +12,11 @@ import (
 
 func insertBundles(t *testing.T, cmd icmd.Cmd, info dindSwarmAndRegistryInfo) {
 	// Push an application so that we can later pull it by digest
-	cmd.Command = dockerCli.Command("app", "build", filepath.Join("testdata", "push-pull", "push-pull.dockerapp"), "--tag", info.registryAddress+"/c-myapp")
+	cmd.Command = dockerCli.Command("app", "build", "--tag", info.registryAddress+"/c-myapp", filepath.Join("testdata", "push-pull"))
 	icmd.RunCmd(cmd).Assert(t, icmd.Success)
-	cmd.Command = dockerCli.Command("app", "build", filepath.Join("testdata", "simple", "simple.dockerapp"), "--tag", "b-simple-app")
+	cmd.Command = dockerCli.Command("app", "build", "--tag", "b-simple-app", filepath.Join("testdata", "simple"))
 	icmd.RunCmd(cmd).Assert(t, icmd.Success)
-	cmd.Command = dockerCli.Command("app", "build", filepath.Join("testdata", "simple", "simple.dockerapp"), "--tag", "a-simple-app")
+	cmd.Command = dockerCli.Command("app", "build", "--tag", "a-simple-app", filepath.Join("testdata", "simple"))
 	icmd.RunCmd(cmd).Assert(t, icmd.Success)
 }
 
@@ -86,7 +86,7 @@ func TestImageTag(t *testing.T) {
 		}
 
 		// given a first available image
-		cmd.Command = dockerCli.Command("app", "build", filepath.Join("testdata", "simple", "simple.dockerapp"), "--tag", "a-simple-app")
+		cmd.Command = dockerCli.Command("app", "build", "--tag", "a-simple-app", filepath.Join("testdata", "simple"))
 		icmd.RunCmd(cmd).Assert(t, icmd.Success)
 
 		singleImageExpectation := `APP IMAGE           APP NAME
@@ -175,7 +175,7 @@ c-simple-app:latest simple
 `)
 
 		// given a new application
-		cmd.Command = dockerCli.Command("app", "build", filepath.Join("testdata", "push-pull", "push-pull.dockerapp"), "--tag", "push-pull")
+		cmd.Command = dockerCli.Command("app", "build", "--tag", "push-pull", filepath.Join("testdata", "push-pull"))
 		icmd.RunCmd(cmd).Assert(t, icmd.Success)
 		expectImageListOutput(t, cmd, `APP IMAGE           APP NAME
 a-simple-app:0.1    simple

e2e/pushpull_test.go

@@ -196,7 +196,7 @@ func TestPushInstallBundle(t *testing.T) {
 		ref := info.registryAddress + "/test/push-bundle"
 
 		// render the app to a bundle, we use the app from the push pull test above.
-		cmd.Command = dockerCli.Command("app", "build", filepath.Join("testdata", "push-pull", "push-pull.dockerapp"), "--tag", "a-simple-app:1.0.0")
+		cmd.Command = dockerCli.Command("app", "build", "--tag", "a-simple-app:1.0.0", filepath.Join("testdata", "push-pull"))
 		icmd.RunCmd(cmd).Assert(t, icmd.Success)
 
 		// push it and install to check it is available
@@ -244,7 +244,7 @@ func TestPushInstallBundle(t *testing.T) {
 			cmdIsolatedStore.Env = append(cmdIsolatedStore.Env, "DOCKER_CONTEXT=swarm-context")
 
 			// bundle the app again but this time with a tag to store it into the bundle store
-			cmdIsolatedStore.Command = dockerCli.Command("app", "build", filepath.Join("testdata", "push-pull", "push-pull.dockerapp"), "--tag", ref2)
+			cmdIsolatedStore.Command = dockerCli.Command("app", "build", "--tag", ref2, filepath.Join("testdata", "push-pull"))
 			icmd.RunCmd(cmdIsolatedStore).Assert(t, icmd.Success)
 			// Push the app without tagging it explicitly
 			cmdIsolatedStore.Command = dockerCli.Command("app", "push", ref2)

internal/commands/build/build.go

@@ -6,7 +6,9 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"io/ioutil"
 	"os"
+	"path/filepath"
 	"strconv"
 	"strings"
 
@@ -34,14 +36,15 @@ type buildOptions struct {
 	progress string
 	pull     bool
 	tag      string
+	folder   string
 }
 
 func Cmd(dockerCli command.Cli) *cobra.Command {
 	var opts buildOptions
 	cmd := &cobra.Command{
-		Use:     "build [APP_NAME] [OPTIONS]",
+		Use:     "build [OPTIONS] [CONTEXT_PATH]",
 		Short:   "Build service images for the application",
-		Example: `$ docker app build myapp.dockerapp --tag my/app:1.0.0`,
+		Example: `$ docker app build --tag my/app:1.0.0 .`,
 		Args:    cli.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			ref, err := runBuild(dockerCli, args[0], opts)
@@ -56,12 +59,13 @@ func Cmd(dockerCli command.Cli) *cobra.Command {
 	flags.BoolVar(&opts.noCache, "no-cache", false, "Do not use cache when building the image")
 	flags.StringVar(&opts.progress, "progress", "auto", "Set type of progress output (auto, plain, tty). Use plain to show container output")
 	flags.StringVarP(&opts.tag, "tag", "t", "", "Application image and optionally a tag in the 'image:tag' format")
+	flags.StringVarP(&opts.folder, "folder", "f", "", "Docker app folder containing application definition")
 	flags.BoolVar(&opts.pull, "pull", false, "Always attempt to pull a newer version of the image")
 
 	return cmd
 }
 
-func runBuild(dockerCli command.Cli, application string, opt buildOptions) (reference.Reference, error) {
+func runBuild(dockerCli command.Cli, contextPath string, opt buildOptions) (reference.Reference, error) {
 	err := checkMinimalEngineVersion(dockerCli)
 	if err != nil {
 		return nil, err
@@ -73,18 +77,35 @@ func runBuild(dockerCli command.Cli, application string, opt buildOptions) (refe
 		return nil, err
 	}
 
+	application, err := getAppFolder(opt, contextPath)
+	if err != nil {
+		return nil, err
+	}
+
 	app, err := packager.Extract(application)
 	if err != nil {
 		return nil, err
 	}
 	defer app.Cleanup()
 
-	buildopts, err := parseCompose(app, opt)
+	serviceTag := ref
+	if serviceTag == nil {
+		named, err := reference.WithName(app.Metadata().Name)
+		if err != nil {
+			return nil, err
+		}
+		serviceTag, err = reference.WithTag(named, app.Metadata().Version)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	buildopts, err := parseCompose(app, contextPath, opt, serviceTag)
 	if err != nil {
 		return nil, err
 	}
 
-	buildopts["com.docker.app.invocation-image"], err = createInvocationImageBuildOptions(dockerCli, app)
+	buildopts["com.docker.app.invocation-image"], err = createInvocationImageBuildOptions(dockerCli, app, serviceTag)
 	if err != nil {
 		return nil, err
 	}
@@ -126,6 +147,25 @@ func runBuild(dockerCli command.Cli, application string, opt buildOptions) (refe
 	return packager.PersistInBundleStore(ref, bundle)
 }
 
+func getAppFolder(opt buildOptions, contextPath string) (string, error) {
+	application := opt.folder
+	if application == "" {
+		files, err := ioutil.ReadDir(contextPath)
+		if err != nil {
+			return "", err
+		}
+		for _, f := range files {
+			if strings.HasSuffix(f.Name(), ".dockerapp") {
+				if application != "" {
+					return "", fmt.Errorf("%s contains multiple *.dockerapp folders, use -f option to select the one to build", contextPath)
+				}
+				application = filepath.Join(contextPath, f.Name())
+			}
+		}
+	}
+	return application, nil
+}
+
 func checkMinimalEngineVersion(dockerCli command.Cli) error {
 	info, err := dockerCli.Client().Info(appcontext.Context())
 	if err != nil {
@@ -165,7 +205,7 @@ func updateBundle(dockerCli command.Cli, bundle *bundle.Bundle, resp map[string]
 	return nil
 }
 
-func createInvocationImageBuildOptions(dockerCli command.Cli, app *types.App) (build.Options, error) {
+func createInvocationImageBuildOptions(dockerCli command.Cli, app *types.App, serviceTag reference.Reference) (build.Options, error) {
 	buildContext := bytes.NewBuffer(nil)
 	if err := packager.PackInvocationImageContext(dockerCli, app, buildContext); err != nil {
 		return build.Options{}, err
@@ -176,6 +216,7 @@ func createInvocationImageBuildOptions(dockerCli command.Cli, app *types.App) (b
 			ContextPath: "-",
 		},
 		Session: []session.Attachable{authprovider.NewDockerAuthProvider(os.Stderr)},
+		Tags:    []string{fmt.Sprintf("%s-installer", serviceTag.String())},
 	}, nil
 }
 

internal/commands/build/compose.go

@@ -1,9 +1,12 @@
 package build
 
 import (
+	"errors"
 	"fmt"
 	"path"
 
+	"github.com/docker/distribution/reference"
+
 	"github.com/docker/app/types"
 	"github.com/docker/buildx/build"
 	"github.com/docker/cli/cli/compose/loader"
@@ -12,7 +15,7 @@ import (
 
 // parseCompose do parse app compose file and extract buildx Options
 // We don't rely on bake's ReadTargets + TargetsToBuildOpt here as we have to skip environment variable interpolation
-func parseCompose(app *types.App, options buildOptions) (map[string]build.Options, error) {
+func parseCompose(app *types.App, contextPath string, options buildOptions, reference reference.Reference) (map[string]build.Options, error) {
 	parsed, err := loader.ParseYAML(app.Composes()[0])
 	if err != nil {
 		return nil, err
@@ -29,22 +32,19 @@ func parseCompose(app *types.App, options buildOptions) (map[string]build.Option
 			continue
 		}
 
-		var tags []string
-		if service.Image != nil && *service.Image != "" {
-			tags = []string{*service.Image}
+		if service.Name == "installer" {
+			return nil, errors.New("'installer' is a reserved service name, please fix your docker-compose.yml file")
 		}
 
-		// FIXME docker app init should update relative paths
-		// compose file has been copied to x.dockerapp, so the relative path to build context get broken
-		contextPath := path.Join(app.Path, "..", service.Build.Context)
+		tags := []string{fmt.Sprintf("%s-%s", reference.String(), service.Name)}
+
 		if service.Build.Dockerfile == "" {
 			service.Build.Dockerfile = "Dockerfile"
 		}
-		dockerfile := path.Join(contextPath, service.Build.Dockerfile)
 		opts[service.Name] = build.Options{
 			Inputs: build.Inputs{
-				ContextPath:    contextPath,
-				DockerfilePath: dockerfile,
+				ContextPath:    path.Join(contextPath, service.Build.Context),
+				DockerfilePath: path.Join(contextPath, service.Build.Context, service.Build.Dockerfile),
 			},
 			BuildArgs: flatten(service.Build.Args),
 			NoCache:   options.noCache,

internal/commands/build/compose_test.go

@@ -3,12 +3,18 @@ package build
 import (
 	"testing"
 
+	"github.com/docker/distribution/reference"
+
 	"github.com/docker/app/internal/packager"
 	"github.com/docker/buildx/build"
 	"gotest.tools/assert"
 )
 
 func Test_parseCompose(t *testing.T) {
+
+	tag, err := reference.Parse("test:1.0")
+	assert.NilError(t, err)
+
 	tests := []struct {
 		name    string
 		service string
@@ -22,7 +28,7 @@ func Test_parseCompose(t *testing.T) {
 					ContextPath:    "testdata/web",
 					DockerfilePath: "testdata/web/Dockerfile",
 				},
-				Tags: []string{"frontend"},
+				Tags: []string{"test:1.0-web"},
 			},
 		},
 		{
@@ -33,6 +39,7 @@ func Test_parseCompose(t *testing.T) {
 					ContextPath:    "testdata/web",
 					DockerfilePath: "testdata/web/Dockerfile.custom",
 				},
+				Tags: []string{"test:1.0-web"},
 			},
 		},
 		{
@@ -44,16 +51,15 @@ func Test_parseCompose(t *testing.T) {
 					DockerfilePath: "testdata/web/Dockerfile",
 				},
 				BuildArgs: map[string]string{"foo": "bar"},
+				Tags:      []string{"test:1.0-web"},
 			},
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-
 			app, err := packager.Extract("testdata/" + tt.name)
 			assert.NilError(t, err)
-
-			got, err := parseCompose(app, buildOptions{})
+			got, err := parseCompose(app, "testdata", buildOptions{}, tag)
 			assert.NilError(t, err)
 			_, ok := got["dontwant"]
 			assert.Assert(t, !ok, "parseCompose() should have excluded 'dontwant' service")

internal/packager/extract.go

@@ -14,11 +14,7 @@ import (
 )
 
 // findApp looks for an app in CWD or subdirs
-func findApp() (string, error) {
-	cwd, err := os.Getwd()
-	if err != nil {
-		return "", errors.Wrap(err, "cannot resolve current working directory")
-	}
+func FindApp(cwd string) (string, error) {
 	if strings.HasSuffix(cwd, internal.AppExtension) {
 		return cwd, nil
 	}
@@ -47,8 +43,11 @@ func findApp() (string, error) {
 // If nothing is found, it looks for an image and loads it
 func Extract(name string, ops ...func(*types.App) error) (*types.App, error) {
 	if name == "" {
-		var err error
-		if name, err = findApp(); err != nil {
+		cwd, err := os.Getwd()
+		if err != nil {
+			return nil, errors.Wrap(err, "cannot resolve current working directory")
+		}
+		if name, err = FindApp(cwd); err != nil {
 			return nil, err
 		}
 	}