working commit

pkg/repocli/client_test.go

@@ -1,159 +0,0 @@
-package repocli
-
-import (
-	"github.com/stretchr/testify/require"
-
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"math/rand"
-	"testing"
-	"time"
-)
-
-func xxxTestClientGetManifest(t *testing.T) {
-	rawrepo := "mirror.gcr.io/alpine"
-	tags := []string{
-		"3.20.0",
-		"sha256:29e5ba63e79337818e6c63cfcc68e2ab4e9ca483853b2de303bfbfba9372426c",
-	}
-	for _, tag := range tags {
-		cli := NewClient()
-		ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)
-		exist, mime, man, err := cli.GetManifest(ctx, rawrepo, tag)
-		require.NoError(t, err)
-		require.True(t, exist)
-
-		fmt.Printf("Type: %s\n", mime)
-		buffer := bytes.NewBuffer(nil)
-		err = json.Indent(buffer, man, " ", "    ")
-		require.NoError(t, err)
-		//fmt.Printf("%s\n", buffer.String())
-	}
-}
-
-func xxxTestClientManifestExists(t *testing.T) {
-	rawrepo := "mirror.gcr.io/alpine"
-	tags := []string{
-		"3.20.0",
-		"sha256:29e5ba63e79337818e6c63cfcc68e2ab4e9ca483853b2de303bfbfba9372426c",
-	}
-	for _, tag := range tags {
-
-		cli := NewClient()
-		ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)
-		exist, mime, size, csum, err := cli.ManifestExists(ctx, rawrepo, tag)
-		require.NoError(t, err)
-		require.True(t, exist)
-
-		fmt.Printf("MIME: %s\n", mime)
-		fmt.Printf("Size: %d\n", size)
-		fmt.Printf("Sum: %s\n", csum)
-		fmt.Printf("Typ: %d\n", DigestType(csum))
-	}
-}
-
-func xxxTestClientBlobExists(t *testing.T) {
-	rawrepos := []string{
-		"mirror.gcr.io/alpine",
-	}
-	for _, rawrepo := range rawrepos {
-		cli := NewClient()
-		ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)
-		digest := "sha256:3b8747b05489980f63da1d2b8e5a444c55777f69540394397b0bc1c76c3e41f2"
-		exist, size, err := cli.BlobExists(ctx, rawrepo, digest)
-		require.NoError(t, err)
-		require.True(t, exist)
-
-		fmt.Printf("Size: %d\n", size)
-	}
-}
-
-func xxxTestClientGetBlob(t *testing.T) {
-	rawrepos := []string{
-		"mirror.gcr.io/alpine",
-	}
-	for _, rawrepo := range rawrepos {
-		cli := NewClient()
-		ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)
-		buffer := bytes.NewBuffer(nil)
-		digest := "sha256:3b8747b05489980f63da1d2b8e5a444c55777f69540394397b0bc1c76c3e41f2"
-		exist, err := cli.GetBlob(ctx, rawrepo, buffer, digest)
-		require.NoError(t, err)
-		require.True(t, exist)
-		fmt.Printf("Size: %d\n", len(buffer.Bytes()))
-	}
-}
-
-func xxxxTestClientGetUpload(t *testing.T) {
-	rawrepos := []string{
-		"mstore:mstore@localhost:1025/alpine:3.20.0",
-	}
-	cli := NewClient()
-	cli.UseMiddleware(NewBasicAuthMiddleware("mstore", "mstore"))
-
-	for _, rawrepo := range rawrepos {
-		var err error
-		var loc string
-		{
-			ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)
-			loc, err = cli.GetUpload(ctx, rawrepo)
-			require.NoError(t, err)
-			fmt.Printf("Upload Location: %s\n", loc)
-		}
-		{
-			srcsize := 1024 + 145
-			srcdata := make([]byte, srcsize)
-			_, err = rand.Read(srcdata)
-			require.NoError(t, err)
-
-			src := bytes.NewReader(srcdata)
-			//digest := SHA256Digest(srcdata)
-
-			ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)
-			bloc, err := cli.PatchUpload(ctx, rawrepo, src, loc, int64(len(srcdata)))
-			require.NoError(t, err)
-			fmt.Printf("Path Location: %s\n", bloc)
-		}
-		{
-			srcsize := 1024 + 145
-			srcdata := make([]byte, srcsize)
-			_, err = rand.Read(srcdata)
-			require.NoError(t, err)
-
-			src := bytes.NewReader(srcdata)
-			digest := SHA256Digest(srcdata)
-
-			ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)
-			bloc, err := cli.PutUpload(ctx, rawrepo, src, loc, digest, int64(len(srcdata)))
-			require.NoError(t, err)
-			fmt.Printf("Put blob Location: %s\n", bloc)
-		}
-
-	}
-}
-
-func xxxxTestClientGetToken(t *testing.T) {
-	var token string
-	var err error
-	{
-		cli := NewClient()
-		cli.UseMiddleware(NewBasicAuthMiddleware("onborodin", "2Albert334"))
-		ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)
-		token, err = cli.GetToken(ctx, "https://auth.docker.io/token")
-		require.NoError(t, err)
-
-	}
-	fmt.Printf("Token: %s\n", token)
-	{
-		rawrepo := "docker.io/onborodin/toolbox:0.18"
-		cli := NewClient()
-		cli.UseMiddleware(NewBearerAuthMiddleware(token))
-		ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)
-		loc, err := cli.GetUpload(ctx, rawrepo)
-		require.NoError(t, err)
-		fmt.Printf("Upload Location: %s\n", loc)
-	}
-
-}

pkg/repocli/copyctx.go

@@ -1,39 +0,0 @@
-package repocli
-
-import (
-	"context"
-	"errors"
-	"io"
-)
-
-func Copy(ctx context.Context, writer io.Writer, reader io.Reader) (int64, error) {
-	var err error
-	var size int64
-	var halt bool
-	buffer := make([]byte, 1024*4)
-	for {
-		select {
-		case <-ctx.Done():
-			err = errors.New("Break copy by context")
-			break
-		default:
-		}
-		rsize, err := reader.Read(buffer)
-		if err == io.EOF {
-			err = nil
-			halt = true
-		}
-		if err != nil {
-			return size, err
-		}
-		wsize, err := writer.Write(buffer[0:rsize])
-		size += int64(wsize)
-		if err != nil {
-			return size, err
-		}
-		if halt {
-			break
-		}
-	}
-	return size, err
-}

pkg/repocli/copyctx_test.go

@@ -1,28 +0,0 @@
-package repocli
-
-import (
-	"github.com/stretchr/testify/require"
-
-	"bytes"
-	"context"
-	"fmt"
-	"math/rand"
-	"testing"
-)
-
-func TestCopy(t *testing.T) {
-	srcsize := 1024 + 145
-	srcdata := make([]byte, srcsize)
-	_, err := rand.Read(srcdata)
-	require.NoError(t, err)
-
-	src := bytes.NewReader(srcdata)
-	dst := bytes.NewBuffer(nil)
-
-	ctx := context.Background()
-	recsize, err := Copy(ctx, dst, src)
-	require.NoError(t, err)
-
-	fmt.Printf("Size: %d %d\n", recsize, srcsize)
-	require.Equal(t, int64(srcsize), recsize)
-}

pkg/repocli/digest.go

@@ -1,147 +0,0 @@
-package repocli
-
-import (
-	"crypto/sha256"
-	"crypto/sha512"
-	"hash"
-
-	"encoding/hex"
-	"errors"
-	"strings"
-)
-
-func SHA256Digest(src []byte) string {
-	hasher := sha256.New()
-	hasher.Write(src)
-	sum := hasher.Sum(nil)
-	return "sha256:" + hex.EncodeToString(sum)
-}
-
-func SHA512Digest(src []byte) string {
-	hasher := sha512.New()
-	hasher.Write(src)
-	sum := hasher.Sum(nil)
-	return "sha512:" + hex.EncodeToString(sum)
-}
-
-type Algorithm int
-
-const (
-	Undefined Algorithm = iota
-	SHA256
-	SHA384
-	SHA512
-)
-
-func DigestType(digest string) Algorithm {
-	var err error
-	var algorithm Algorithm
-	digest = strings.ToLower(digest)
-	digest = strings.TrimPrefix(digest, "sha256:")
-	digest = strings.TrimPrefix(digest, "sha384:")
-	digest = strings.TrimPrefix(digest, "sha512:")
-	decoded, err := hex.DecodeString(digest)
-	if err != nil {
-		return Undefined
-	}
-	switch len(decoded) {
-	case 32:
-		algorithm = SHA256
-	case 48:
-		algorithm = SHA384
-	case 64:
-		algorithm = SHA512
-	default:
-		algorithm = Undefined
-	}
-	return algorithm
-}
-
-type Digest struct {
-	algorithm Algorithm
-	decoded   []byte
-}
-
-func NewDigestFromBytes(algorithm Algorithm, payload []byte) *Digest {
-	var sum []byte
-	var hasher hash.Hash
-	switch algorithm {
-	case SHA512:
-		hasher = sha512.New()
-	case SHA384:
-		hasher = sha512.New384()
-	default:
-		hasher = sha256.New()
-	}
-	hasher.Write(payload)
-	sum = hasher.Sum(nil)
-	digest := &Digest{
-		algorithm: algorithm,
-		decoded:   sum,
-	}
-	return digest
-}
-
-func ParseDigest(str string) (*Digest, error) {
-	var err error
-	digest := &Digest{}
-
-	str = strings.ToLower(str)
-	str = strings.TrimPrefix(str, "sha256:")
-	str = strings.TrimPrefix(str, "sha384:")
-	str = strings.TrimPrefix(str, "sha512:")
-
-	decoded, err := hex.DecodeString(str)
-	if err != nil {
-		err := errors.New("Can't decode digest")
-		return digest, err
-	}
-	digest.decoded = decoded
-	switch len(decoded) {
-	case 32:
-		digest.algorithm = SHA256
-	case 48:
-		digest.algorithm = SHA384
-	case 64:
-		digest.algorithm = SHA512
-	default:
-		err = errors.New("Unknown digest type")
-		return digest, err
-	}
-	return digest, err
-}
-
-func (dig *Digest) Hex() string {
-	return hex.EncodeToString(dig.decoded)
-}
-
-func (dig *Digest) Algorithm() Algorithm {
-	return dig.algorithm
-}
-
-func (dig *Digest) Prefix() string {
-	var prefix string
-	switch dig.algorithm {
-	case SHA256:
-		prefix = "sha256"
-	case SHA384:
-		prefix = "sha384"
-	case SHA512:
-		prefix = "sha512"
-	}
-	return prefix
-}
-
-func (dig *Digest) Encoded() string {
-	var prefix string
-	switch dig.algorithm {
-	case SHA256:
-		prefix = "sha256"
-	case SHA384:
-		prefix = "sha384"
-	case SHA512:
-		prefix = "sha512"
-	}
-	hexx := hex.EncodeToString(dig.decoded)
-	return prefix + ":" + hexx
-}

pkg/repocli/getman.go

@@ -5,9 +5,12 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"io"
 	"net/http"
 	"strconv"
 	"strings"
+
+	ocidigest "github.com/opencontainers/go-digest"
 )
 
 func (cli *Client) GetManifest(ctx context.Context, rawrepo, tag string) (bool, string, []byte, error) {
@@ -55,36 +58,29 @@ func (cli *Client) GetManifest(ctx context.Context, rawrepo, tag string) (bool,
 		err := fmt.Errorf("Empty MIME type declaration")
 		return exist, mime, man, err
 	}
-	buffer := bytes.NewBuffer(nil)
+	digstr := resp.Header.Get("Docker-Content-Digest")
-	recSize, err := Copy(ctx, buffer, resp.Body)
+	if digstr == "" {
-	if manSize != recSize {
-		err := fmt.Errorf("Mismatch declared and actual body size, %d and %d", manSize, recSize)
-		return exist, mime, man, err
-	}
-	man = buffer.Bytes()
-
-	csum := resp.Header.Get("Docker-Content-Digest")
-	if csum == "" {
 		err := fmt.Errorf("Empty digest declaration")
 		return exist, mime, man, err
 	}
-	csum = strings.ToLower(csum)
+	digstr = strings.ToLower(digstr)
-	switch DigestType(csum) {
+	digobj, err := ocidigest.Parse(digstr)
-	case SHA256:
+	if err != nil {
-		if csum != SHA256Digest(man) {
-			err := fmt.Errorf("Mismatch digest and actual declaration")
 		return exist, mime, man, err
 	}
-	case SHA512:
+	verifier := digobj.Verifier()
-		if csum != SHA256Digest(man) {
+	buffer := bytes.NewBuffer(nil)
-			err := fmt.Errorf("Mismatch digest and actual declaration")
+	mwriter := io.MultiWriter(buffer, verifier)
+	recSize, err := Copy(ctx, mwriter, resp.Body)
+	if manSize != recSize {
+		err := fmt.Errorf("Mismatch declared and actual size")
 		return exist, mime, man, err
 	}
-	default:
+	man = buffer.Bytes()
-		err := fmt.Errorf("Unknown digest type: %s", csum)
+	if !verifier.Verified() {
+		err := fmt.Errorf("Mismatch digest declaration and actual")
 		return exist, mime, man, err
 	}
-
 	exist = true
 	return exist, mime, man, err
 }

pkg/repocli/imager.go

@@ -5,6 +5,7 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
+	"fmt"
 	"io"
 	"os"
 	"path/filepath"
@@ -30,27 +31,124 @@ func NewEmptyImager(place string) *Imager {
 	return imager
 }
 
+func NewImagerFromPlace(place string) (*Imager, error) {
+	var err error
+	imager := &Imager{
+		index: ocispec.Index{
+			MediaType: MediaTypeOIIv1,
+			Manifests: make([]ocispec.Descriptor, 0),
+		},
+		place: place,
+	}
+	imager.index.SchemaVersion = 2
+
+	// Read and check layout version
+	lpath := filepath.Join(imager.place, ocispec.ImageLayoutFile)
+	lfile, err := os.OpenFile(lpath, os.O_RDONLY, 0)
+	if err != nil {
+		return imager, err
+	}
+	defer lfile.Close()
+	buffer := bytes.NewBuffer(nil)
+	if err != nil {
+		return imager, err
+	}
+	_, err = io.Copy(buffer, lfile)
+	if err != nil {
+		return imager, err
+	}
+	layout := ocispec.ImageLayout{}
+	err = json.Unmarshal(buffer.Bytes(), &layout)
+	if err != nil {
+		return imager, err
+	}
+	if layout.Version != ocispec.ImageLayoutVersion {
+		err = fmt.Errorf("Unknown layout version: %s", layout.Version)
+		return imager, err
+	}
+	// Read image
+	ipath := filepath.Join(imager.place, ocispec.ImageIndexFile)
+	ifile, err := os.OpenFile(ipath, os.O_RDONLY, 0)
+	if err != nil {
+		return imager, err
+	}
+	defer ifile.Close()
+	buffer = bytes.NewBuffer(nil)
+	_, err = io.Copy(buffer, ifile)
+	if err != nil {
+		return imager, err
+	}
+	err = json.Unmarshal(buffer.Bytes(), &imager.index)
+	if err != nil {
+		return imager, err
+	}
+	return imager, err
+}
+
+func (ima *Imager) ReadManifest(ctx context.Context, digstr string) (bool, string, []byte, error) {
+	var exist bool
+	var mime string
+	var man []byte
+	var err error
+
+	digobj, err := ocidigest.Parse(digstr)
+	if err != nil {
+		return exist, mime, man, err
+	}
+
+	var size int64
+	for _, descr := range ima.index.Manifests {
+		if digstr == descr.Digest.Encoded() {
+			size = descr.Size
+			mime = descr.MediaType
+			exist = true
+		}
+	}
+
+	subdir := string(digobj.Algorithm())
+	mpath := filepath.Join(ima.place, ocispec.ImageBlobsDir, subdir, digobj.Encoded())
+	mfile, err := os.OpenFile(mpath, os.O_RDONLY, 0)
+	if err != nil {
+		return exist, mime, man, err
+	}
+	defer mfile.Close()
+
+	buffer := bytes.NewBuffer(nil)
+	verifier := digobj.Verifier()
+	mwriter := io.MultiWriter(verifier, buffer)
+	readsize, err := io.Copy(mwriter, mfile)
+	man = buffer.Bytes()
+	if size != readsize {
+		err = errors.New("Mismatch manigest sizes")
+		return exist, mime, man, err
+	}
+	if !verifier.Verified() {
+		err = errors.New("Mismatch manifest digests")
+		return exist, mime, man, err
+	}
+	return exist, mime, man, err
+}
+
 func (ima *Imager) WriteManifest(ctx context.Context, digest, mime string, payload []byte) error {
 	var err error
-	digestobj, err := ocidigest.Parse(digest)
+	digobj, err := ocidigest.Parse(digest)
 	if err != nil {
 		return err
 	}
-	subdir := string(digestobj.Algorithm())
+	subdir := string(digobj.Algorithm())
-	dir := filepath.Join(ima.place, subdir)
+	blobdir := filepath.Join(ima.place, ocispec.ImageBlobsDir, subdir)
-	err = os.MkdirAll(dir, 0750)
+	err = os.MkdirAll(blobdir, 0750)
 	if err != nil {
 		return err
 	}
-	mpath := filepath.Join(dir, digestobj.Encoded())
+	mpath := filepath.Join(blobdir, digobj.Encoded())
 	mfile, err := os.OpenFile(mpath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0640)
 	if err != nil {
 		return err
 	}
 	defer mfile.Close()
 	reader := bytes.NewReader(payload)
-
+	verifier := digobj.Verifier()
-	verifier := digestobj.Verifier()
 	mwriter := io.MultiWriter(verifier, mfile)
 	recsize, err := io.Copy(mwriter, reader)
 	size := int64(len(payload))
@@ -64,23 +162,27 @@ func (ima *Imager) WriteManifest(ctx context.Context, digest, mime string, paylo
 	}
 	descr := ocispec.Descriptor{
 		MediaType: mime,
-		Digest:    digestobj,
+		Digest:    digobj,
 		Size:      size,
 	}
 	ima.index.Manifests = append(ima.index.Manifests, descr)
+	return err
+}
+
+func (ima *Imager) WriteIndex(ctx context.Context) error {
 	indexdat, err := json.Marshal(ima.index)
 	if err != nil {
 		return err
 	}
 	// Flush index
-	ipath := filepath.Join(dir, "index.json")
+	ipath := filepath.Join(ima.place, ocispec.ImageIndexFile)
 	ifile, err := os.OpenFile(ipath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0640)
 	if err != nil {
 		return err
 	}
 	defer ifile.Close()
-	reader = bytes.NewReader(indexdat)
+	reader := bytes.NewReader(indexdat)
-	recsize, err = io.Copy(ifile, reader)
+	recsize, err := io.Copy(ifile, reader)
 	if err != nil {
 		return err
 	}
@@ -88,27 +190,50 @@ func (ima *Imager) WriteManifest(ctx context.Context, digest, mime string, paylo
 		err = errors.New("Mismatch index sizes")
 		return err
 	}
+	// Flush layout
+	lpath := filepath.Join(ima.place, ocispec.ImageLayoutFile)
+	lfile, err := os.OpenFile(lpath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0640)
+	if err != nil {
+		return err
+	}
+	defer lfile.Close()
+	layout := ocispec.ImageLayout{
+		Version: ocispec.ImageLayoutVersion,
+	}
+	layoutdat, err := json.Marshal(layout)
+	reader = bytes.NewReader(layoutdat)
+	if err != nil {
+		return err
+	}
+	recsize, err = io.Copy(lfile, reader)
+	if err != nil {
+		return err
+	}
+	if recsize != int64(len(layoutdat)) {
+		err = errors.New("Mismatch layout sizes")
+		return err
+	}
 	return err
 }
 
 func (ima *Imager) WriteLayer(ctx context.Context, digest string, size int64, reader io.Reader) error {
 	var err error
-	digestobj, err := ocidigest.Parse(digest)
+	digobj, err := ocidigest.Parse(digest)
 	if err != nil {
 		return err
 	}
-	subdir := string(digestobj.Algorithm())
+	subdir := string(digobj.Algorithm())
-	dir := filepath.Join(ima.place, subdir)
+	blobdir := filepath.Join(ima.place, ocispec.ImageBlobsDir, subdir)
-	err = os.MkdirAll(dir, 0750)
+	err = os.MkdirAll(blobdir, 0750)
 	if err != nil {
 		return err
 	}
-	fpath := filepath.Join(dir, digestobj.Encoded())
+	fpath := filepath.Join(blobdir, digobj.Encoded())
 	file, err := os.OpenFile(fpath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0640)
 	if err != nil {
 		return err
 	}
-	verifier := digestobj.Verifier()
+	verifier := digobj.Verifier()
 	mwriter := io.MultiWriter(verifier, file)
 	recsize, err := io.Copy(mwriter, reader)
 	if size != recsize {
@@ -121,3 +246,38 @@ func (ima *Imager) WriteLayer(ctx context.Context, digest string, size int64, re
 	}
 	return err
 }
+
+func (ima *Imager) ReadLayer(ctx context.Context, digstr string, writer io.Writer) (bool, error) {
+	var exist bool
+	var err error
+	digobj, err := ocidigest.Parse(digstr)
+	if err != nil {
+		return exist, err
+	}
+	subdir := string(digobj.Algorithm())
+	mpath := filepath.Join(ima.place, ocispec.ImageBlobsDir, subdir, digobj.Encoded())
+	stat, err := os.Stat(mpath)
+	if err != nil {
+		return exist, err
+	}
+	size := stat.Size()
+	mfile, err := os.OpenFile(mpath, os.O_RDONLY, 0)
+	if err != nil {
+		return exist, err
+	}
+	defer mfile.Close()
+
+	verifier := digobj.Verifier()
+	mwriter := io.MultiWriter(verifier, writer)
+	readsize, err := io.Copy(mwriter, mfile)
+	if size != readsize {
+		err = errors.New("Mismatch layer sizes")
+		return exist, err
+	}
+	if !verifier.Verified() {
+		err = errors.New("Mismatch layer digests")
+		return exist, err
+	}
+	exist = true
+	return exist, err
+}

pkg/repocli/imager_test.go

@@ -7,27 +7,46 @@ import (
 	"bytes"
 	"context"
 	"fmt"
+	"io"
 	"testing"
 	"time"
 )
 
 func TestDigest(t *testing.T) {
+	place := "a/" //t.TempDir()
+	fmt.Printf("Place: %s\n", place)
+	var digstr string
+	{
 		payload := []byte("Hello, World")
-	digestobj := ocidigest.FromBytes(payload)
+		digobj := ocidigest.FromBytes(payload)
-	require.NotNil(t, digestobj)
+		require.NotNil(t, digobj)
-	enc := digestobj.Encoded()
+		digstr = digobj.String()
-	fmt.Printf("Digest: %s\n", enc)
+		fmt.Printf("Digest: %s\n", digstr)
-	fmt.Printf("Alg: %s\n", digestobj.Algorithm())
+		fmt.Printf("Alg: %s\n", digobj.Algorithm())
 
 		ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)
-	tmpdir := t.TempDir()
+		imager := NewEmptyImager(place)
-	imager := NewEmptyImager(tmpdir)
 		require.NotNil(t, imager)
-	digest := fmt.Sprintf("%s:%s", digestobj.Algorithm(), digestobj.Encoded())
+		digest := fmt.Sprintf("%s:%s", digobj.Algorithm(), digobj.Encoded())
 		size := int64(len(payload))
 		reader := bytes.NewReader(payload)
 
 		err := imager.WriteLayer(ctx, digest, size, reader)
 		require.NoError(t, err)
 
+		err = imager.WriteIndex(ctx)
+		require.NoError(t, err)
+
+	}
+	{
+		imager, err := NewImagerFromPlace(place)
+		require.NoError(t, err)
+		require.NotNil(t, imager)
+
+		ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)
+		exist, err := imager.ReadLayer(ctx, digstr, io.Discard)
+		require.NoError(t, err)
+		require.True(t, exist)
+
+	}
 }

pkg/repocli/jwt.go

@@ -1,63 +0,0 @@
-package repocli
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"net/http"
-	//"strconv"
-	//"strings"
-	"encoding/json"
-	"time"
-)
-
-type JWT struct {
-	Token       string    `json:"token"`
-	AccessToken string    `json:"access_token"`
-	ExpiresIn   int       `json:"expires_in"`
-	IssuedAt    time.Time `json:"issued_at"`
-}
-
-func (cli *Client) GetToken(ctx context.Context, uri string) (string, error) {
-	var err error
-	var token string
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, uri, nil)
-	if err != nil {
-		return token, err
-	}
-	req.Header.Set("User-Agent", cli.userAgent)
-	req.Header.Set("Accept", "*/*")
-	resp, err := cli.httpClient.Do(req)
-	if err != nil {
-		return token, err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode == http.StatusNotFound {
-		return token, err
-	}
-	if resp.StatusCode != http.StatusOK {
-		err := fmt.Errorf("Unxected response code %s", resp.Status)
-		return token, err
-	}
-	mime := resp.Header.Get("Content-Type")
-	if mime != "application/json" {
-		err := fmt.Errorf("Empty MIME type declaration")
-		return token, err
-	}
-	buffer := bytes.NewBuffer(nil)
-	recSize, err := Copy(ctx, buffer, resp.Body)
-	if recSize == 0 {
-		err := fmt.Errorf("Zero actual body size")
-		return token, err
-	}
-	tokenJson := buffer.Bytes()
-	jwt := &JWT{}
-	err = json.Unmarshal(tokenJson, jwt)
-	if err != nil {
-		return token, err
-	}
-	token = jwt.Token
-	return token, err
-}

pkg/repocli/mimetyp.go

@@ -1,6 +0,0 @@
-package repocli
-
-const (
-// MediaTypeDDMLv2 = "application/vnd.docker.distribution.manifest.list.v2+json"
-// MediaTypeDDMv2  = "application/vnd.docker.distribution.manifest.v2+json"
-)

pkg/repocli/putman.go

@@ -5,6 +5,8 @@ import (
 	"context"
 	"fmt"
 	"net/http"
+
+	ocidigest "github.com/opencontainers/go-digest"
 )
 
 func (cli *Client) PutManifest(ctx context.Context, rawrepo, tag string, man []byte, mime string) error {
@@ -22,7 +24,9 @@ func (cli *Client) PutManifest(ctx context.Context, rawrepo, tag string, man []b
 		return err
 	}
 	req.Header.Set("User-Agent", cli.userAgent)
-	req.Header.Set("Docker-Content-Digest", SHA256Digest(man))
+	// TODO: digest
+	digestobj := ocidigest.NewDigestFromBytes(ocidigest.SHA256, man)
+	req.Header.Set("Docker-Content-Digest", digestobj.Encoded())
 	req.Header.Set("Content-Type", mime)
 	resp, err := cli.httpClient.Do(req)
 	if err != nil {

pkg/repocli/repo_test.go

@@ -5,6 +5,8 @@ import (
 
 	"fmt"
 	"testing"
+
+	"mstore/pkg/digest"
 )
 
 func xxxTestResrerer(t *testing.T) {
@@ -13,13 +15,13 @@ func xxxTestResrerer(t *testing.T) {
 
 	fmt.Printf("Manifest:\t%s\n", ref.Manifest("3.30.0"))
 
-	digest := SHA256Digest([]byte("qwerty"))
+	digobj := digest.NewDigest(digest.SHA256, []byte("qwerty"))
-	fmt.Printf("Blob:\t\t%s\n", ref.Blob(digest))
+	fmt.Printf("Blob:\t\t%s\n", ref.Blob(digobj.Encoded()))
 	fmt.Printf("POST:\t\t%s\n", ref.Upload())
 	uuid := "8be4df61-93ca-11d2-aa0d-00e098032b8c"
 	rawurl, err := ref.Patch(uuid)
 	require.NoError(t, err)
 	fmt.Printf("PATH:\t\t%s\n", rawurl)
-	rawurl, err = ref.Put(uuid, digest)
+	rawurl, err = ref.Put(uuid, digobj.Encoded())
 	fmt.Printf("PUT:\t\t%s\n", rawurl)
 }