Merge pull request #102 from buildpack/new-defaults

New defaults

Dockerfile

@@ -22,9 +22,8 @@ RUN \
   groupadd pack --gid ${pack_gid} && \
   useradd --uid ${pack_uid} --gid ${pack_gid} -m -s /bin/bash pack
 
-ENV PACK_USER_ID=${pack_uid}
-ENV PACK_GROUP_ID=${pack_gid}
-ENV PACK_USER_GID=${pack_gid}
+ENV CNB_USER_ID=${pack_uid}
+ENV CNB_GROUP_ID=${pack_gid}
 
 COPY --from=builder /go/bin /lifecycle
 

analyzer.go

@@ -4,6 +4,8 @@ import (
 	"log"
 	"os"
 
+	"github.com/pkg/errors"
+
 	"github.com/buildpack/lifecycle/image"
 )
 
@@ -13,6 +15,8 @@ type Analyzer struct {
 	LayersDir  string
 	In         []byte
 	Out, Err   *log.Logger
+	UID        int
+	GID        int
 }
 
 func (a *Analyzer) Analyze(image image.Image) error {
@@ -71,8 +75,8 @@ func (a *Analyzer) Analyze(image image.Image) error {
 	if current := os.Getuid(); err != nil {
 		return err
 	} else if current == 0 {
-		if err := fixPerms(a.LayersDir); err != nil {
-			return err
+		if err := recursiveChown(a.LayersDir, a.UID, a.GID); err != nil {
+			return errors.Wrapf(err, "chowning layers dir to '%d/%d'", a.UID, a.GID)
 		}
 	}
 	return nil

analyzer_test.go

@@ -51,6 +51,8 @@ func testAnalyzer(t *testing.T, when spec.G, it spec.S) {
 			LayersDir:  layerDir,
 			Out:        log.New(stdout, "", 0),
 			Err:        log.New(stderr, "", 0),
+			UID:        1234,
+			GID:        4321,
 		}
 		mockCtrl = gomock.NewController(t)
 	})
@@ -75,8 +77,6 @@ func testAnalyzer(t *testing.T, when spec.G, it spec.S) {
 		when("image exists", func() {
 			when("image label has compatible metadata", func() {
 				it.Before(func() {
-					h.AssertNil(t, os.Setenv("PACK_USER_ID", "1234"))
-					h.AssertNil(t, os.Setenv("PACK_GROUP_ID", "4321"))
 					image.EXPECT().Found().Return(true, nil)
 					image.EXPECT().Label("io.buildpacks.lifecycle.metadata").Return(`{
   "buildpacks": [
@@ -460,7 +460,7 @@ func testAnalyzer(t *testing.T, when spec.G, it spec.S) {
 						}
 					})
 
-					it("chowns new files to PACK_USER_ID:PACK_GROUP_ID", func() {
+					it("chowns new files to CNB_USER_ID:CNB_GROUP_ID", func() {
 						h.AssertNil(t, analyzer.Analyze(image))
 						h.AssertUidGid(t, layerDir, 1234, 4321)
 						h.AssertUidGid(t, filepath.Join(layerDir, "metdata.buildpack", "valid-launch.toml"), 1234, 4321)

cmd/analyzer/main.go

@@ -19,6 +19,8 @@ var (
 	groupPath  string
 	useDaemon  bool
 	useHelpers bool
+	uid        int
+	gid        int
 )
 
 func init() {
@@ -27,6 +29,8 @@ func init() {
 	cmd.FlagGroupPath(&groupPath)
 	cmd.FlagUseDaemon(&useDaemon)
 	cmd.FlagUseCredHelpers(&useHelpers)
+	cmd.FlagUID(&uid)
+	cmd.FlagGID(&gid)
 }
 
 func main() {
@@ -56,11 +60,13 @@ func analyzer() error {
 		LayersDir:  layersDir,
 		Out:        log.New(os.Stdout, "", 0),
 		Err:        log.New(os.Stderr, "", 0),
+		UID:        uid,
+		GID:        gid,
 	}
 
 	var err error
 	var previousImage image.Image
-	factory, err := image.NewFactory(image.WithOutWriter(os.Stdout), image.WithEnvKeychain, image.WithLegacyEnvKeychain)
+	factory, err := image.NewFactory(image.WithOutWriter(os.Stdout), image.WithEnvKeychain)
 	if err != nil {
 		return err
 	}

cmd/cmd.go

@@ -10,92 +10,78 @@ import (
 )
 
 const (
-	DefaultLayersDir      = "/workspace"
-	DefaultAppDir         = "/workspace/app"
-	DefaultBuildpacksDir  = "/buildpacks"
-	DefaultPlatformDir    = "/platform"
-	DefaultOrderPath      = "/buildpacks/order.toml"
-	DefaultGroupPath      = "./group.toml"
-	DefaultStackPath      = "/buildpacks/stack.toml"
-	DefaultPlanPath       = "./plan.toml"
-	DefaultUseDaemon      = false
-	DefaultUseCredHelpers = false
-
-	EnvRunImage           = "PACK_RUN_IMAGE"
-	EnvUID                = "PACK_USER_ID"
-	EnvGID                = "PACK_GROUP_ID"
-	EnvLayersDir          = "PACK_LAYERS_DIR"
-	EnvAppDir             = "PACK_APP_DIR"
-	EnvLegacyRegistryAuth = "PACK_REGISTRY_AUTH"
-	EnvRegistryAuth       = "CNB_REGISTRY_AUTH"
-	EnvStackPath          = "CNB_STACK_PATH"
+	DefaultLayersDir     = "/layers"
+	DefaultAppDir        = "/workspace"
+	DefaultBuildpacksDir = "/buildpacks"
+	DefaultPlatformDir   = "/platform"
+	DefaultOrderPath     = "/buildpacks/order.toml"
+	DefaultGroupPath     = "./group.toml"
+	DefaultStackPath     = "/buildpacks/stack.toml"
+	DefaultPlanPath      = "./plan.toml"
+
+	EnvLayersDir     = "CNB_LAYERS_DIR"
+	EnvAppDir        = "CNB_APP_DIR"
+	EnvBuildpacksDir = "CNB_BUILDPACKS_DIR"
+	EnvPlatformDir   = "CNB_PLATFORM_DIR"
+	EnvOrderPath     = "CNB_ORDER_PATH"
+	EnvGroupPath     = "CNB_GROUP_PATH"
+	EnvStackPath     = "CNB_STACK_PATH"
+	EnvPlanPath      = "CNB_PLAN_PATH"
+	EnvUseDaemon     = "CNB_USE_DAEMON"       // defaults to false
+	EnvUseHelpers    = "CNB_USE_CRED_HELPERS" // defaults to false
+	EnvRunImage      = "CNB_RUN_IMAGE"
+	EnvCacheImage    = "CNB_CACHE_IMAGE"
+	EnvUID           = "CNB_USER_ID"
+	EnvGID           = "CNB_GROUP_ID"
+	EnvRegistryAuth  = "CNB_REGISTRY_AUTH"
 )
 
-type Labels map[string]string
-
-func (l Labels) String() string {
-	b := strings.Builder{}
-	for k, v := range l {
-		b.WriteString(fmt.Sprintf("%s=%s ", k, v))
-	}
-	return b.String()
-}
-
-func (l Labels) Set(value string) error {
-	pair := strings.Split(value, "=")
-	if len(pair) != 2 {
-		return fmt.Errorf("please provide valid labels in a key=value format")
-	}
-	l[pair[0]] = pair[1]
-	return nil
-}
-
 func FlagLayersDir(dir *string) {
-	flag.StringVar(dir, "layers", DefaultLayersDir, "path to layers directory")
+	flag.StringVar(dir, "layers", envWithDefault(EnvLayersDir, DefaultLayersDir), "path to layers directory")
 }
 
 func FlagAppDir(dir *string) {
-	flag.StringVar(dir, "app", DefaultAppDir, "path to app directory")
+	flag.StringVar(dir, "app", envWithDefault(EnvAppDir, DefaultAppDir), "path to app directory")
 }
 
 func FlagBuildpacksDir(dir *string) {
-	flag.StringVar(dir, "buildpacks", DefaultBuildpacksDir, "path to buildpacks directory")
+	flag.StringVar(dir, "buildpacks", envWithDefault(EnvBuildpacksDir, DefaultBuildpacksDir), "path to buildpacks directory")
 }
 
 func FlagPlatformDir(dir *string) {
-	flag.StringVar(dir, "platform", DefaultPlatformDir, "path to platform directory")
+	flag.StringVar(dir, "platform", envWithDefault(EnvPlatformDir, DefaultPlatformDir), "path to platform directory")
 }
 
 func FlagOrderPath(path *string) {
-	flag.StringVar(path, "order", DefaultOrderPath, "path to order.toml")
+	flag.StringVar(path, "order", envWithDefault(EnvOrderPath, DefaultOrderPath), "path to order.toml")
 }
 
 func FlagGroupPath(path *string) {
-	flag.StringVar(path, "group", DefaultGroupPath, "path to group.toml")
+	flag.StringVar(path, "group", envWithDefault(EnvGroupPath, DefaultGroupPath), "path to group.toml")
 }
 
 func FlagStackPath(path *string) {
 	flag.StringVar(path, "stack", envWithDefault(EnvStackPath, DefaultStackPath), "path to stack.toml")
 }
 
 func FlagPlanPath(path *string) {
-	flag.StringVar(path, "plan", DefaultPlanPath, "path to plan.toml")
+	flag.StringVar(path, "plan", envWithDefault(EnvPlanPath, DefaultPlanPath), "path to plan.toml")
 }
 
 func FlagRunImage(image *string) {
 	flag.StringVar(image, "image", os.Getenv(EnvRunImage), "reference to run image")
 }
 
 func FlagCacheImage(image *string) {
-	flag.StringVar(image, "image", "", "cache image tag name")
+	flag.StringVar(image, "image", os.Getenv(EnvCacheImage), "cache image tag name")
 }
 
 func FlagUseDaemon(use *bool) {
-	flag.BoolVar(use, "daemon", DefaultUseDaemon, "export to docker daemon")
+	flag.BoolVar(use, "daemon", boolEnv(EnvUseDaemon), "export to docker daemon")
 }
 
 func FlagUseCredHelpers(use *bool) {
-	flag.BoolVar(use, "helpers", DefaultUseCredHelpers, "use credential helpers")
+	flag.BoolVar(use, "helpers", boolEnv(EnvUseHelpers), "use credential helpers")
 }
 
 func FlagUID(uid *int) {
@@ -167,6 +153,15 @@ func intEnv(k string) int {
 	return d
 }
 
+func boolEnv(k string) bool {
+	v := os.Getenv(k)
+	b, err := strconv.ParseBool(v)
+	if err != nil {
+		return false
+	}
+	return b
+}
+
 func envWithDefault(key string, defaultVal string) string {
 	if envVal := os.Getenv(key); envVal != "" {
 		return envVal

cmd/exporter/main.go

@@ -82,7 +82,7 @@ func export() error {
 		ArtifactsDir: artifactsDir,
 	}
 
-	factory, err := image.NewFactory(image.WithOutWriter(os.Stdout), image.WithEnvKeychain, image.WithLegacyEnvKeychain)
+	factory, err := image.NewFactory(image.WithOutWriter(os.Stdout), image.WithEnvKeychain)
 	if err != nil {
 		return err
 	}

cmd/restorer/main.go

@@ -17,12 +17,16 @@ var (
 	cacheImageTag string
 	layersDir     string
 	groupPath     string
+	uid           int
+	gid           int
 )
 
 func init() {
 	cmd.FlagLayersDir(&layersDir)
 	cmd.FlagCacheImage(&cacheImageTag)
 	cmd.FlagGroupPath(&groupPath)
+	cmd.FlagUID(&uid)
+	cmd.FlagGID(&gid)
 }
 
 func main() {
@@ -48,6 +52,8 @@ func restore() error {
 		Buildpacks: group.Buildpacks,
 		Out:        log.New(os.Stdout, "", 0),
 		Err:        log.New(os.Stderr, "", 0),
+		UID:        uid,
+		GID:        gid,
 	}
 
 	factory, err := image.NewFactory(image.WithOutWriter(os.Stdout))

exporter_test.go

@@ -287,18 +287,18 @@ func testExporter(t *testing.T, when spec.G, it spec.S) {
 				h.AssertEq(t, metadata.Stack.RunImage.Mirrors, []string{"registry.example.com/some/run", "other.example.com/some/run"})
 			})
 
-			it("sets PACK_LAYERS_DIR", func() {
+			it("sets CNB_LAYERS_DIR", func() {
 				h.AssertNil(t, exporter.Export(layersDir, appDir, fakeRunImage, fakeOriginalImage, launcherPath, stack))
 
-				val, err := fakeRunImage.Env("PACK_LAYERS_DIR")
+				val, err := fakeRunImage.Env("CNB_LAYERS_DIR")
 				h.AssertNil(t, err)
 				h.AssertEq(t, val, layersDir)
 			})
 
-			it("sets PACK_APP_DIR", func() {
+			it("sets CNB_APP_DIR", func() {
 				h.AssertNil(t, exporter.Export(layersDir, appDir, fakeRunImage, fakeOriginalImage, launcherPath, stack))
 
-				val, err := fakeRunImage.Env("PACK_APP_DIR")
+				val, err := fakeRunImage.Env("CNB_APP_DIR")
 				h.AssertNil(t, err)
 				h.AssertEq(t, val, appDir)
 			})
@@ -497,18 +497,18 @@ func testExporter(t *testing.T, when spec.G, it spec.S) {
 				})
 			})
 
-			it("sets PACK_LAYERS_DIR", func() {
+			it("sets CNB_LAYERS_DIR", func() {
 				h.AssertNil(t, exporter.Export(layersDir, appDir, fakeRunImage, nonExistingOriginalImage, launcherPath, stack))
 
-				val, err := fakeRunImage.Env("PACK_LAYERS_DIR")
+				val, err := fakeRunImage.Env("CNB_LAYERS_DIR")
 				h.AssertNil(t, err)
 				h.AssertEq(t, val, layersDir)
 			})
 
-			it("sets PACK_APP_DIR", func() {
+			it("sets CNB_APP_DIR", func() {
 				h.AssertNil(t, exporter.Export(layersDir, appDir, fakeRunImage, nonExistingOriginalImage, launcherPath, stack))
 
-				val, err := fakeRunImage.Env("PACK_APP_DIR")
+				val, err := fakeRunImage.Env("CNB_APP_DIR")
 				h.AssertNil(t, err)
 				h.AssertEq(t, val, appDir)
 			})