Stage local Docker tags for remote pushes

Author: chruffins

pkg/cmd/push.go

@@ -25,31 +25,37 @@ var pushCmd = cli.Command{
 	ArgsUsage: "IMAGE [TARGET]",
 	Description: `Push images between Docker, Hypeman, and remote registries.
 
-  hypeman push IMAGE
-      Upload IMAGE from the local Docker daemon into Hypeman.
+  hypeman push TARGET
+      Push TARGET to its remote registry. If TARGET exists in local Docker,
+      stage it in Hypeman first.
 
   hypeman push IMAGE TARGET
       Push an image already in Hypeman to TARGET. Waits for completion.
 
-  hypeman push --detach IMAGE TARGET
+  hypeman push --detach TARGET
       Queue a remote push and return its ID.
 
-Use "hypeman push local IMAGE [TARGET]" to make the local-upload flow explicit.
-The --detach flag applies to remote pushes, not local uploads.
+Use "hypeman push local IMAGE [TARGET]" for Docker-daemon uploads that should
+only go to Hypeman. The --detach flag applies to remote pushes, not local
+uploads.
 
 Push jobs can be inspected while they run:
   hypeman push ls
   hypeman push inspect <id>
 
 Examples:
-  # Push a cached image to ECR
+  # Push a local Docker tag to ECR
+  docker tag alpine:latest 123456789.dkr.ecr.us-east-1.amazonaws.com/myapp:v1
+  hypeman push 123456789.dkr.ecr.us-east-1.amazonaws.com/myapp:v1
+
+  # Push a cached Hypeman image to ECR
   hypeman push alpine:latest 123456789.dkr.ecr.us-east-1.amazonaws.com/myapp:v1
 
   # Push with credentials read from stdin
-  echo "$ECR_PASSWORD" | hypeman push alpine:latest registry.example.com/app:v1 \
+  echo "$ECR_PASSWORD" | hypeman push registry.example.com/app:v1 \
     --username AWS --password-stdin
 
-  # Upload a local Docker image into Hypeman
+  # Upload a local Docker image into Hypeman only
   hypeman push local nginx:latest`,
 	Flags:           pushRemoteFlags(),
 	Commands:        []*cli.Command{&pushLocalCmd, &pushCreateCmd, &pushListCmd, &pushGetCmd},
@@ -69,12 +75,11 @@ func handlePush(ctx context.Context, cmd *cli.Command) error {
 	args := cmd.Args().Slice()
 	switch len(args) {
 	case 1:
-		// Keep the old one-argument form working for existing scripts.
-		return handleLocalPush(ctx, cmd)
+		return handleRemotePushTarget(ctx, cmd, args[0])
 	case 2:
 		return runRemotePush(ctx, cmd, args[0], args[1])
 	default:
-		return fmt.Errorf("image reference required\nUsage: hypeman push <image> [target]")
+		return fmt.Errorf("image reference required\nUsage: hypeman push <target> or hypeman push <image> <target>")
 	}
 }
 
@@ -90,6 +95,10 @@ func handleLocalPush(ctx context.Context, cmd *cli.Command) error {
 		targetName = args[1]
 	}
 
+	return pushLocalImage(ctx, cmd, sourceImage, targetName, nil)
+}
+
+func pushLocalImage(ctx context.Context, cmd *cli.Command, sourceImage, targetName string, img v1.Image) error {
 	baseURL := resolveBaseURL(cmd)
 
 	parsedURL, err := url.Parse(baseURL)
@@ -123,10 +132,12 @@ func handleLocalPush(ctx context.Context, cmd *cli.Command) error {
 		return fmt.Errorf("invalid target: %w", err)
 	}
 
-	fmt.Fprintf(os.Stderr, "Loading image %s from Docker...\n", sourceImage)
-	img, err := daemon.Image(srcRef)
-	if err != nil {
-		return fmt.Errorf("load image: %w", err)
+	if img == nil {
+		fmt.Fprintf(os.Stderr, "Loading image %s from Docker...\n", sourceImage)
+		img, err = daemon.Image(srcRef)
+		if err != nil {
+			return fmt.Errorf("load image: %w", err)
+		}
 	}
 
 	fmt.Fprintf(os.Stderr, "The push refers to repository [%s]\n", dstRef.Context().Name())

pkg/cmd/pushcmd.go

@@ -4,11 +4,13 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"net/url"
 	"os"
 	"strings"
 	"time"
 
 	"github.com/google/go-containerregistry/pkg/name"
+	"github.com/google/go-containerregistry/pkg/v1/daemon"
 	"github.com/kernel/hypeman-go"
 	"github.com/kernel/hypeman-go/option"
 	"github.com/tidwall/gjson"
@@ -85,6 +87,48 @@ var pushGetCmd = cli.Command{
 	HideHelpCommand: true,
 }
 
+func handleRemotePushTarget(ctx context.Context, cmd *cli.Command, target string) error {
+	if err := validateRemotePushTarget(target); err != nil {
+		return err
+	}
+
+	// A local Docker tag can be staged into Hypeman before the remote push.
+	// When no matching local image exists, use the already-cached Hypeman image.
+	srcRef, err := name.ParseReference(target)
+	if err == nil {
+		if img, loadErr := daemon.Image(srcRef); loadErr == nil {
+			fmt.Fprintf(os.Stderr, "Staging local image %s in Hypeman...\n", target)
+			if err := pushLocalImage(ctx, cmd, target, target, img); err != nil {
+				return err
+			}
+
+			client := hypeman.NewClient(getDefaultRequestOptions(cmd)...)
+			imported, err := client.Images.Get(ctx, url.PathEscape(target))
+			if err != nil {
+				return fmt.Errorf("get staged image %s: %w", target, err)
+			}
+			if err := waitForImageReady(ctx, &client, imported); err != nil {
+				return err
+			}
+		}
+	}
+
+	return runRemotePush(ctx, cmd, target, target)
+}
+
+func validateRemotePushTarget(target string) error {
+	if _, err := name.ParseReference(target); err != nil {
+		return fmt.Errorf("invalid target %q: %w", target, err)
+	}
+	lastSlash := strings.LastIndex(target, "/")
+	lastColon := strings.LastIndex(target, ":")
+	lastAt := strings.LastIndex(target, "@")
+	if lastAt > lastSlash || lastColon <= lastSlash {
+		return fmt.Errorf("target %q must include an explicit tag", target)
+	}
+	return nil
+}
+
 func handlePushCreate(ctx context.Context, cmd *cli.Command) error {
 	args := cmd.Args().Slice()
 	if len(args) != 2 {
@@ -150,16 +194,7 @@ func validateRemotePushReferences(image, target string) error {
 	if _, err := name.ParseReference(image); err != nil {
 		return fmt.Errorf("invalid source image %q: %w", image, err)
 	}
-	if _, err := name.ParseReference(target); err != nil {
-		return fmt.Errorf("invalid target %q: %w", target, err)
-	}
-	lastSlash := strings.LastIndex(target, "/")
-	lastColon := strings.LastIndex(target, ":")
-	lastAt := strings.LastIndex(target, "@")
-	if lastAt > lastSlash || lastColon <= lastSlash {
-		return fmt.Errorf("target %q must include an explicit tag", target)
-	}
-	return nil
+	return validateRemotePushTarget(target)
 }
 
 func pushPassword(cmd *cli.Command) (string, error) {

pkg/cmd/pushcmd_test.go

@@ -20,8 +20,8 @@ func TestPushCommandStructure(t *testing.T) {
 	assert.Contains(t, pushListCmd.Aliases, "ls")
 	assert.Contains(t, pushGetCmd.Aliases, "inspect")
 
-	// The parent action remains reachable for the legacy local-upload form and
-	// the new direct remote-push form.
+	// The parent action remains reachable for the staged local and direct
+	// remote-push forms.
 	assert.NotNil(t, pushCmd.Action)
 }