From ef9a3f6b2020628d22e53ab4eb3946242b809706 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9E=D0=BB=D0=B5=D0=B3=20=D0=91=D0=BE=D1=80=D0=BE=D0=B4?= =?UTF-8?q?=D0=B8=D0=BD?= Date: Fri, 6 Mar 2026 16:26:04 +0200 Subject: [PATCH] working commit --- pkg/repocli/client_test.go | 159 ----------------------------- pkg/repocli/copyctx.go | 39 -------- pkg/repocli/copyctx_test.go | 28 ------ pkg/repocli/digest.go | 147 --------------------------- pkg/repocli/getman.go | 46 ++++----- pkg/repocli/imager.go | 194 ++++++++++++++++++++++++++++++++---- pkg/repocli/imager_test.go | 49 ++++++--- pkg/repocli/jwt.go | 63 ------------ pkg/repocli/mimetyp.go | 6 -- pkg/repocli/putman.go | 6 +- pkg/repocli/repo_test.go | 8 +- 11 files changed, 242 insertions(+), 503 deletions(-) delete mode 100644 pkg/repocli/client_test.go delete mode 100644 pkg/repocli/copyctx.go delete mode 100644 pkg/repocli/copyctx_test.go delete mode 100644 pkg/repocli/digest.go delete mode 100644 pkg/repocli/jwt.go delete mode 100644 pkg/repocli/mimetyp.go diff --git a/pkg/repocli/client_test.go b/pkg/repocli/client_test.go deleted file mode 100644 index efcb220..0000000 --- a/pkg/repocli/client_test.go +++ /dev/null @@ -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) - } - -} diff --git a/pkg/repocli/copyctx.go b/pkg/repocli/copyctx.go deleted file mode 100644 index b9a8acf..0000000 --- a/pkg/repocli/copyctx.go +++ /dev/null @@ -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 -} diff --git a/pkg/repocli/copyctx_test.go b/pkg/repocli/copyctx_test.go deleted file mode 100644 index b6c991e..0000000 --- a/pkg/repocli/copyctx_test.go +++ /dev/null @@ -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) -} diff --git a/pkg/repocli/digest.go b/pkg/repocli/digest.go deleted file mode 100644 index 739c4e5..0000000 --- a/pkg/repocli/digest.go +++ /dev/null @@ -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 -} diff --git a/pkg/repocli/getman.go b/pkg/repocli/getman.go index a51dc84..986d894 100644 --- a/pkg/repocli/getman.go +++ b/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) - recSize, err := Copy(ctx, buffer, resp.Body) - 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 == "" { + digstr := resp.Header.Get("Docker-Content-Digest") + if digstr == "" { err := fmt.Errorf("Empty digest declaration") return exist, mime, man, err } - csum = strings.ToLower(csum) - switch DigestType(csum) { - case SHA256: - if csum != SHA256Digest(man) { - err := fmt.Errorf("Mismatch digest and actual declaration") - return exist, mime, man, err - } - case SHA512: - if csum != SHA256Digest(man) { - err := fmt.Errorf("Mismatch digest and actual declaration") - return exist, mime, man, err - } - default: - err := fmt.Errorf("Unknown digest type: %s", csum) + digstr = strings.ToLower(digstr) + digobj, err := ocidigest.Parse(digstr) + if err != nil { + return exist, mime, man, err + } + verifier := digobj.Verifier() + buffer := bytes.NewBuffer(nil) + 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 + } + man = buffer.Bytes() + if !verifier.Verified() { + err := fmt.Errorf("Mismatch digest declaration and actual") return exist, mime, man, err } - exist = true return exist, mime, man, err } diff --git a/pkg/repocli/imager.go b/pkg/repocli/imager.go index d9eaea6..69ffac6 100644 --- a/pkg/repocli/imager.go +++ b/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()) - dir := filepath.Join(ima.place, subdir) - err = os.MkdirAll(dir, 0750) + subdir := string(digobj.Algorithm()) + blobdir := filepath.Join(ima.place, ocispec.ImageBlobsDir, subdir) + 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 := digestobj.Verifier() + verifier := digobj.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) - recsize, err = io.Copy(ifile, reader) + reader := bytes.NewReader(indexdat) + 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()) - dir := filepath.Join(ima.place, subdir) - err = os.MkdirAll(dir, 0750) + subdir := string(digobj.Algorithm()) + blobdir := filepath.Join(ima.place, ocispec.ImageBlobsDir, subdir) + 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 +} diff --git a/pkg/repocli/imager_test.go b/pkg/repocli/imager_test.go index adbc6cd..3bd6761 100644 --- a/pkg/repocli/imager_test.go +++ b/pkg/repocli/imager_test.go @@ -7,27 +7,46 @@ import ( "bytes" "context" "fmt" + "io" "testing" "time" ) func TestDigest(t *testing.T) { - payload := []byte("Hello, World") - digestobj := ocidigest.FromBytes(payload) - require.NotNil(t, digestobj) - enc := digestobj.Encoded() - fmt.Printf("Digest: %s\n", enc) - fmt.Printf("Alg: %s\n", digestobj.Algorithm()) + place := "a/" //t.TempDir() + fmt.Printf("Place: %s\n", place) + var digstr string + { + payload := []byte("Hello, World") + digobj := ocidigest.FromBytes(payload) + require.NotNil(t, digobj) + digstr = digobj.String() + fmt.Printf("Digest: %s\n", digstr) + fmt.Printf("Alg: %s\n", digobj.Algorithm()) - ctx, _ := context.WithTimeout(context.Background(), 10*time.Second) - tmpdir := t.TempDir() - imager := NewEmptyImager(tmpdir) - require.NotNil(t, imager) - digest := fmt.Sprintf("%s:%s", digestobj.Algorithm(), digestobj.Encoded()) - size := int64(len(payload)) - reader := bytes.NewReader(payload) + ctx, _ := context.WithTimeout(context.Background(), 10*time.Second) + imager := NewEmptyImager(place) + require.NotNil(t, imager) + 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.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) + + } } diff --git a/pkg/repocli/jwt.go b/pkg/repocli/jwt.go deleted file mode 100644 index 6c1b218..0000000 --- a/pkg/repocli/jwt.go +++ /dev/null @@ -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 -} diff --git a/pkg/repocli/mimetyp.go b/pkg/repocli/mimetyp.go deleted file mode 100644 index 0a0f941..0000000 --- a/pkg/repocli/mimetyp.go +++ /dev/null @@ -1,6 +0,0 @@ -package repocli - -const ( -// MediaTypeDDMLv2 = "application/vnd.docker.distribution.manifest.list.v2+json" -// MediaTypeDDMv2 = "application/vnd.docker.distribution.manifest.v2+json" -) diff --git a/pkg/repocli/putman.go b/pkg/repocli/putman.go index e199cc2..a3da22e 100644 --- a/pkg/repocli/putman.go +++ b/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 { diff --git a/pkg/repocli/repo_test.go b/pkg/repocli/repo_test.go index 9d930a3..5599629 100644 --- a/pkg/repocli/repo_test.go +++ b/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")) - fmt.Printf("Blob:\t\t%s\n", ref.Blob(digest)) + digobj := digest.NewDigest(digest.SHA256, []byte("qwerty")) + 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) }