add support for pack to extend base images using daemon

internal/build/docker.go

@@ -21,4 +21,5 @@ type DockerClient interface {
 	ContainerInspect(ctx context.Context, container string) (types.ContainerJSON, error)
 	ContainerRemove(ctx context.Context, container string, options types.ContainerRemoveOptions) error
 	CopyToContainer(ctx context.Context, container, path string, content io.Reader, options types.CopyToContainerOptions) error
+	ImageBuild(ctx context.Context, buildContext io.Reader, options types.ImageBuildOptions) (types.ImageBuildResponse, error)
 }

internal/build/helper.go

@@ -0,0 +1,90 @@
+package build
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/BurntSushi/toml"
+	"github.com/buildpacks/lifecycle/buildpack"
+	"github.com/buildpacks/lifecycle/cmd"
+
+	"github.com/buildpacks/pack/pkg/logging"
+)
+
+const (
+	DockerfileKindBuild = "build"
+	DockerfileKindRun   = "run"
+)
+
+type Extensions struct {
+	Extensions []buildpack.GroupElement
+}
+
+func (extensions *Extensions) DockerFiles(kind string, path string, logger logging.Logger) ([]buildpack.DockerfileInfo, error) {
+	var dockerfiles []buildpack.DockerfileInfo
+	for _, ext := range extensions.Extensions {
+		dockerfile, err := extensions.ReadDockerFile(path, kind, ext.ID)
+		if err != nil {
+			return nil, err
+		}
+		if dockerfile != nil {
+			logger.Debugf("Found %s Dockerfile for extension '%s'", kind, ext.ID)
+			switch kind {
+			case DockerfileKindBuild:
+				// will implement later
+			case DockerfileKindRun:
+				buildpack.ValidateRunDockerfile(dockerfile, logger)
+			default:
+				return nil, fmt.Errorf("unknown dockerfile kind: %s", kind)
+			}
+			dockerfiles = append(dockerfiles, *dockerfile)
+		}
+	}
+	return dockerfiles, nil
+}
+
+func (extensions *Extensions) ReadDockerFile(path string, kind string, extID string) (*buildpack.DockerfileInfo, error) {
+	dockerfilePath := filepath.Join(path, kind, escapeID(extID), "Dockerfile")
+	if _, err := os.Stat(dockerfilePath); err != nil {
+		return nil, nil
+	}
+	return &buildpack.DockerfileInfo{
+		ExtensionID: extID,
+		Kind:        kind,
+		Path:        dockerfilePath,
+	}, nil
+}
+
+func (extensions *Extensions) SetExtensions(path string, logger logging.Logger) error {
+	groupExt, err := readExtensionsGroup(path)
+	if err != nil {
+		return fmt.Errorf("reading group: %w", err)
+	}
+	for i := range groupExt {
+		groupExt[i].Extension = true
+	}
+	for _, groupEl := range groupExt {
+		if err = cmd.VerifyBuildpackAPI(groupEl.Kind(), groupEl.String(), groupEl.API, logger); err != nil {
+			return err
+		}
+	}
+	extensions.Extensions = groupExt
+	fmt.Println("extensions.Extensions", extensions.Extensions)
+	return nil
+}
+
+func readExtensionsGroup(path string) ([]buildpack.GroupElement, error) {
+	var group buildpack.Group
+	_, err := toml.DecodeFile(filepath.Join(path, "group.toml"), &group)
+	for e := range group.GroupExtensions {
+		group.GroupExtensions[e].Extension = true
+		group.GroupExtensions[e].Optional = true
+	}
+	return group.GroupExtensions, err
+}
+
+func escapeID(id string) string {
+	return strings.ReplaceAll(id, "/", "_")
+}

internal/build/lifecycle_execution.go

@@ -3,16 +3,20 @@ package build
 import (
 	"context"
 	"fmt"
+	"io"
+
 	"math/rand"
 	"os"
 	"path/filepath"
 	"strconv"
 
+	"github.com/BurntSushi/toml"
+
 	"github.com/buildpacks/pack/pkg/cache"
 
-	"github.com/BurntSushi/toml"
 	"github.com/buildpacks/lifecycle/api"
 	"github.com/buildpacks/lifecycle/auth"
+	"github.com/docker/docker/api/types"
 	"github.com/google/go-containerregistry/pkg/authn"
 	"github.com/google/go-containerregistry/pkg/name"
 	"github.com/pkg/errors"
@@ -21,6 +25,7 @@ import (
 	"github.com/buildpacks/pack/internal/builder"
 	"github.com/buildpacks/pack/internal/paths"
 	"github.com/buildpacks/pack/internal/style"
+	"github.com/buildpacks/pack/pkg/archive"
 	"github.com/buildpacks/pack/pkg/logging"
 )
 
@@ -247,12 +252,18 @@ func (l *LifecycleExecution) Run(ctx context.Context, phaseFactoryCreator PhaseF
 		}
 
 		if l.platformAPI.AtLeast("0.12") && l.hasExtensionsForRun() {
-			group.Go(func() error {
-				l.logger.Info(style.Step("EXTENDING (RUN)"))
-				return l.ExtendRun(ctx, buildCache, phaseFactory)
-			})
+			if l.opts.Publish {
+				group.Go(func() error {
+					l.logger.Info(style.Step("EXTENDING (RUN)"))
+					return l.ExtendRun(ctx, buildCache, phaseFactory)
+				})
+			} else {
+				group.Go(func() error {
+					l.logger.Info(style.Step("EXTENDING (RUN) BY DAEMON"))
+					return l.ExtendRunByDaemon(ctx, &currentRunImage)
+				})
+			}
 		}
-
 		if err := group.Wait(); err != nil {
 			return err
 		}
@@ -413,6 +424,10 @@ func (l *LifecycleExecution) Detect(ctx context.Context, phaseFactory PhaseFacto
 			CopyOutToMaybe(filepath.Join(l.mountPaths.layersDir(), "analyzed.toml"), l.tmpDir))),
 		If(l.hasExtensions(), WithPostContainerRunOperations(
 			CopyOutToMaybe(filepath.Join(l.mountPaths.layersDir(), "generated", "build"), l.tmpDir))),
+		If(l.hasExtensions(), WithPostContainerRunOperations(
+			CopyOutToMaybe(filepath.Join(l.mountPaths.layersDir(), "generated", "run"), l.tmpDir))),
+		If(l.hasExtensions(), WithPostContainerRunOperations(
+			CopyOutToMaybe(filepath.Join(l.mountPaths.layersDir(), "group.toml"), l.tmpDir))),
 		envOp,
 	)
 
@@ -707,6 +722,50 @@ func (l *LifecycleExecution) ExtendRun(ctx context.Context, buildCache Cache, ph
 	return extend.Run(ctx)
 }
 
+func (l *LifecycleExecution) ExtendRunByDaemon(ctx context.Context, currentRunImage *string) error {
+	defaultFilterFunc := func(file string) bool { return true }
+	var extensions Extensions
+	l.logger.Debugf("extending run image %s", *currentRunImage)
+	fmt.Println("tmpDir: ", l.tmpDir)
+	extensions.SetExtensions(l.tmpDir, l.logger)
+	dockerfiles, err := extensions.DockerFiles(DockerfileKindRun, l.tmpDir, l.logger)
+	if err != nil {
+		return fmt.Errorf("getting %s.Dockerfiles: %w", DockerfileKindRun, err)
+	}
+	fmt.Println("Dockerfiles: ", dockerfiles)
+	fmt.Println("extend: ", dockerfiles[1].Extend)
+	for _, dockerfile := range dockerfiles {
+		if dockerfile.Extend {
+			fmt.Println("dockerfile: ", dockerfile)
+			fmt.Println("dockerfile.Path dir: ", filepath.Dir(dockerfile.Path))
+			buildContext := archive.ReadDirAsTar(filepath.Dir(dockerfile.Path), "/", 0, 0, -1, true, false, defaultFilterFunc)
+			fmt.Println("buildContext: ", buildContext)
+			buildArguments := map[string]*string{}
+			if dockerfile.WithBase == "" {
+				buildArguments["base_image"] = currentRunImage
+			}
+			buildOptions := types.ImageBuildOptions{
+				Context:    buildContext,
+				Dockerfile: "Dockerfile",
+				Tags:       []string{"run-image"},
+				Remove:     true,
+				BuildArgs:  buildArguments,
+			}
+			response, err := l.docker.ImageBuild(ctx, buildContext, buildOptions)
+			if err != nil {
+				return err
+			}
+			defer response.Body.Close()
+			_, err = io.Copy(os.Stdout, response.Body)
+			if err != nil {
+				return err
+			}
+			l.logger.Debugf("build response for the extend: %v", response)
+		}
+	}
+	return nil
+}
+
 func determineDefaultProcessType(platformAPI *api.Version, providedValue string) string {
 	shouldSetForceDefault := platformAPI.Compare(api.MustParse("0.4")) >= 0 &&
 		platformAPI.Compare(api.MustParse("0.6")) < 0

pkg/client/docker.go

@@ -28,4 +28,5 @@ type DockerClient interface {
 	ContainerWait(ctx context.Context, container string, condition containertypes.WaitCondition) (<-chan containertypes.WaitResponse, <-chan error)
 	ContainerAttach(ctx context.Context, container string, options types.ContainerAttachOptions) (types.HijackedResponse, error)
 	ContainerStart(ctx context.Context, container string, options types.ContainerStartOptions) error
+	ImageBuild(ctx context.Context, buildContext io.Reader, options types.ImageBuildOptions) (types.ImageBuildResponse, error)
 }