content: remove Provider.Reader

After some analysis, it was found that Content.Reader was generally
redudant to an io.ReaderAt. This change removes `Content.Reader` in
favor of a `Content.ReaderAt`. In general, `ReaderAt` can perform better
over interfaces with indeterminant latency because it avoids remote
state for reads. Where a reader is required, a helper is provided to
convert it into an `io.SectionReader`.

Signed-off-by: Stephen J Day <stephen.day@docker.com>

content/content.go

@@ -9,9 +9,14 @@ import (
 	"github.com/opencontainers/go-digest"
 )
 
+type ReaderAt interface {
+	io.ReaderAt
+	io.Closer
+	Size() int64
+}
+
 type Provider interface {
-	Reader(ctx context.Context, dgst digest.Digest) (io.ReadCloser, error)
-	ReaderAt(ctx context.Context, dgst digest.Digest) (io.ReaderAt, error)
+	ReaderAt(ctx context.Context, dgst digest.Digest) (ReaderAt, error)
 }
 
 type Ingester interface {

content/helpers.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"sync"
 
 	"github.com/containerd/containerd/errdefs"
@@ -20,17 +19,25 @@ var (
 	}
 )
 
+func NewReader(ra ReaderAt) io.Reader {
+	rd := io.NewSectionReader(ra, 0, ra.Size())
+	return rd
+}
+
 // ReadBlob retrieves the entire contents of the blob from the provider.
 //
 // Avoid using this for large blobs, such as layers.
 func ReadBlob(ctx context.Context, provider Provider, dgst digest.Digest) ([]byte, error) {
-	rc, err := provider.Reader(ctx, dgst)
+	ra, err := provider.ReaderAt(ctx, dgst)
 	if err != nil {
 		return nil, err
 	}
-	defer rc.Close()
+	defer ra.Close()
 
-	return ioutil.ReadAll(rc)
+	p := make([]byte, ra.Size())
+
+	_, err = ra.ReadAt(p, 0)
+	return p, err
 }
 
 // WriteBlob writes data with the expected digest into the content store. If

content/local/readerat.go

@@ -1,26 +1,24 @@
 package local
 
 import (
-	"io"
 	"os"
 )
 
 // readerat implements io.ReaderAt in a completely stateless manner by opening
 // the referenced file for each call to ReadAt.
-type readerAt struct {
-	f string
+type sizeReaderAt struct {
+	size int64
+	fp   *os.File
 }
 
-func (ra readerAt) ReadAt(p []byte, offset int64) (int, error) {
-	fp, err := os.Open(ra.f)
-	if err != nil {
-		return 0, err
-	}
-	defer fp.Close()
-
-	if _, err := fp.Seek(offset, io.SeekStart); err != nil {
-		return 0, err
-	}
-
-	return fp.Read(p)
+func (ra sizeReaderAt) ReadAt(p []byte, offset int64) (int, error) {
+	return ra.fp.ReadAt(p, offset)
+}
+
+func (ra sizeReaderAt) Size() int64 {
+	return ra.size
+}
+
+func (ra sizeReaderAt) Close() error {
+	return ra.fp.Close()
 }

content/local/store.go

@@ -69,22 +69,28 @@ func (s *store) info(dgst digest.Digest, fi os.FileInfo) content.Info {
 	}
 }
 
-// Reader returns an io.ReadCloser for the blob.
-func (s *store) Reader(ctx context.Context, dgst digest.Digest) (io.ReadCloser, error) {
-	fp, err := os.Open(s.blobPath(dgst))
+// ReaderAt returns an io.ReaderAt for the blob.
+func (s *store) ReaderAt(ctx context.Context, dgst digest.Digest) (content.ReaderAt, error) {
+	p := s.blobPath(dgst)
+	fi, err := os.Stat(p)
 	if err != nil {
-		if os.IsNotExist(err) {
-			err = errors.Wrapf(errdefs.ErrNotFound, "content %v", dgst)
+		if !os.IsNotExist(err) {
+			return nil, err
 		}
-		return nil, err
+
+		return nil, errors.Wrapf(errdefs.ErrNotFound, "blob %s expected at %s", dgst, p)
 	}
 
-	return fp, nil
-}
+	fp, err := os.Open(p)
+	if err != nil {
+		if !os.IsNotExist(err) {
+			return nil, err
+		}
 
-// ReaderAt returns an io.ReaderAt for the blob.
-func (s *store) ReaderAt(ctx context.Context, dgst digest.Digest) (io.ReaderAt, error) {
-	return readerAt{f: s.blobPath(dgst)}, nil
+		return nil, errors.Wrapf(errdefs.ErrNotFound, "blob %s expected at %s", dgst, p)
+	}
+
+	return sizeReaderAt{size: fi.Size(), fp: fp}, nil
 }
 
 // Delete removes a blob by its digest.