Implement daemon.Write

cmd/crane/append.go

@@ -75,7 +75,7 @@ func doAppend(src, dst, tar, output string) {
 	}
 
 	if output != "" {
-		if err := tarball.Write(output, dstTag, image, &tarball.WriteOptions{}); err != nil {
+		if err := tarball.WriteToFile(output, dstTag, image, &tarball.WriteOptions{}); err != nil {
 			log.Fatalln(err)
 		}
 		return

cmd/crane/pull.go

@@ -53,7 +53,7 @@ func pull(_ *cobra.Command, args []string) {
 		log.Fatalln(err)
 	}
 
-	if err := tarball.Write(dst, t, i, &tarball.WriteOptions{}); err != nil {
+	if err := tarball.WriteToFile(dst, t, i, &tarball.WriteOptions{}); err != nil {
 		log.Fatalln(err)
 	}
 }

v1/daemon/BUILD.bazel

@@ -16,17 +16,23 @@ go_library(
         "//name:go_default_library",
         "//v1:go_default_library",
         "//v1/tarball:go_default_library",
+        "//vendor/github.com/docker/docker/api/types:go_default_library",
         "//vendor/github.com/docker/docker/client:go_default_library",
+        "//vendor/github.com/pkg/errors:go_default_library",
     ],
 )
 
 go_test(
     name = "go_default_test",
-    srcs = ["image_test.go"],
+    srcs = [
+        "image_test.go",
+        "write_test.go",
+    ],
     data = ["//v1/tarball:test_image_1.tar"],  # keep
     embed = [":go_default_library"],
     deps = [
         "//name:go_default_library",
+        "//v1/random:go_default_library",
         "//v1/tarball:go_default_library",
     ],
 )

v1/daemon/write.go

@@ -15,19 +15,58 @@
 package daemon
 
 import (
-	"fmt"
+	"context"
+	"io"
+	"io/ioutil"
+
+	"github.com/pkg/errors"
+
+	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/client"
 
 	"github.com/google/go-containerregistry/name"
 	"github.com/google/go-containerregistry/v1"
+	"github.com/google/go-containerregistry/v1/tarball"
 )
 
+// API interface for testing.
+type ImageLoader interface {
+	ImageLoad(context.Context, io.Reader, bool) (types.ImageLoadResponse, error)
+}
+
+// This is a variable so we can override in tests.
+var getImageLoader = func() (ImageLoader, error) {
+	return client.NewEnvClient()
+}
+
 // WriteOptions are used to expose optional information to guide or
 // control the image write.
 type WriteOptions struct {
 	// TODO(dlorenc): What kinds of knobs does the daemon expose?
 }
 
-// Write saves the image into the daemon as the given reference.
-func Write(ref name.Reference, img v1.Image, wo WriteOptions) error {
-	return fmt.Errorf("NYI: daemon.Write(%v)", ref)
+// Write saves the image into the daemon as the given tag.
+func Write(tag name.Tag, img v1.Image, wo WriteOptions) (string, error) {
+	cli, err := getImageLoader()
+	if err != nil {
+		return "", err
+	}
+
+	pr, pw := io.Pipe()
+	go func() {
+		pw.CloseWithError(tarball.Write(tag, img, &tarball.WriteOptions{}, pw))
+	}()
+
+	// write the image in docker save format first, then load it
+	resp, err := cli.ImageLoad(context.Background(), pr, false)
+	if err != nil {
+		return "", errors.Wrapf(err, "error loading image")
+	}
+	defer resp.Body.Close()
+	b, readErr := ioutil.ReadAll(resp.Body)
+	response := string(b)
+	if readErr != nil {
+		return response, errors.Wrapf(err, "error reading load response body")
+	}
+	return response, nil
 }

v1/daemon/write_test.go

@@ -0,0 +1,59 @@
+// Copyright 2018 Google LLC All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package daemon
+
+import (
+	"context"
+	"io"
+	"io/ioutil"
+	"strings"
+	"testing"
+
+	"github.com/docker/docker/api/types"
+	"github.com/google/go-containerregistry/name"
+	"github.com/google/go-containerregistry/v1/tarball"
+)
+
+type MockImageLoader struct{}
+
+func (m *MockImageLoader) ImageLoad(_ context.Context, _ io.Reader, _ bool) (types.ImageLoadResponse, error) {
+	return types.ImageLoadResponse{
+		Body: ioutil.NopCloser(strings.NewReader("Loaded")),
+	}, nil
+}
+
+func init() {
+	getImageLoader = func() (ImageLoader, error) {
+		return &MockImageLoader{}, nil
+	}
+}
+
+func TestWriteImage(t *testing.T) {
+	image, err := tarball.ImageFromPath("../tarball/test_image_1.tar", nil)
+	if err != nil {
+		t.Errorf("Error loading image: %v", err.Error())
+	}
+	tag, err := name.NewTag("test_image_2:latest", name.WeakValidation)
+	if err != nil {
+		t.Errorf(err.Error())
+	}
+	response, err := Write(tag, image, WriteOptions{})
+	if err != nil {
+		t.Errorf("Error writing image tar: %s", err.Error())
+	}
+	if !strings.Contains(response, "Loaded") {
+		t.Errorf("Error loading image. Response: %s", response)
+	}
+}

v1/tarball/write.go

@@ -32,20 +32,24 @@ type WriteOptions struct {
 	// TODO(mattmoor): Whether to store things compressed?
 }
 
-// Write saves the image as the given tag in a tarball at the given path.
-func Write(p string, tag name.Tag, img v1.Image, wo *WriteOptions) error {
-	// Write in the compressed format.
-	// This is a tarball, on-disk, with:
-	// One manifest.json file at the top level containing information about several images.
-	// One file for each layer, named after the layer's SHA.
-	// One file for the config blob, named after its SHA.
-
+// WriteToFile writes in the compressed format to a tarball, on disk.
+// This is just syntactic sugar wrapping tarball.Write with a new file.
+func WriteToFile(p string, tag name.Tag, img v1.Image, wo *WriteOptions) error {
 	w, err := os.Create(p)
 	if err != nil {
 		return err
 	}
 	defer w.Close()
 
+	return Write(tag, img, wo, w)
+}
+
+// Write the contents of the image to the provided reader, in the compressed format.
+// The contents are written in the following format:
+// One manifest.json file at the top level containing information about several images.
+// One file for each layer, named after the layer's SHA.
+// One file for the config blob, named after its SHA.
+func Write(tag name.Tag, img v1.Image, wo *WriteOptions, w io.Writer) error {
 	tf := tar.NewWriter(w)
 	defer tf.Close()
 
@@ -58,7 +62,7 @@ func Write(p string, tag name.Tag, img v1.Image, wo *WriteOptions) error {
 	if err != nil {
 		return err
 	}
-	if err := writeFile(tf, cfgName.String(), bytes.NewReader(cfgBlob), int64(len(cfgBlob))); err != nil {
+	if err := writeTarEntry(tf, cfgName.String(), bytes.NewReader(cfgBlob), int64(len(cfgBlob))); err != nil {
 		return err
 	}
 
@@ -94,10 +98,9 @@ func Write(p string, tag name.Tag, img v1.Image, wo *WriteOptions) error {
 			return err
 		}
 
-		if err := writeFile(tf, layerFiles[i], r, blobSize); err != nil {
+		if err := writeTarEntry(tf, layerFiles[i], r, blobSize); err != nil {
 			return err
 		}
-
 	}
 
 	// Generate the tar descriptor and write it.
@@ -112,10 +115,11 @@ func Write(p string, tag name.Tag, img v1.Image, wo *WriteOptions) error {
 	if err != nil {
 		return err
 	}
-	return writeFile(tf, "manifest.json", bytes.NewReader(tdBytes), int64(len(tdBytes)))
+	return writeTarEntry(tf, "manifest.json", bytes.NewReader(tdBytes), int64(len(tdBytes)))
 }
 
-func writeFile(tf *tar.Writer, path string, r io.Reader, size int64) error {
+// write a file to the provided writer with a corresponding tar header
+func writeTarEntry(tf *tar.Writer, path string, r io.Reader, size int64) error {
 	hdr := &tar.Header{
 		Mode:     0644,
 		Typeflag: tar.TypeReg,

v1/tarball/write_test.go

@@ -45,7 +45,7 @@ func TestWrite(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Error creating test tag.")
 	}
-	if err := Write(fp.Name(), tag, randImage, nil); err != nil {
+	if err := WriteToFile(fp.Name(), tag, randImage, nil); err != nil {
 		t.Fatalf("Unexpected error writing tarball: %v", err)
 	}