mirror of
https://github.com/distribution/distribution
synced 2024-11-12 05:45:51 +01:00
2ff77c00ba
Add schema2 manifest implementation. Add a schema2 builder that creates a schema2 manifest from descriptors and a configuration. It will add the configuration to the blob store if necessary. Rename the original schema1 manifest builder to ReferenceBuilder, and create a ConfigBuilder variant that can build a schema1 manifest from an image configuration and set of descriptors. This will be used to translate schema2 manifests to the schema1 format for backward compatibliity, by adding the descriptors from the existing schema2 manifest to the schema1 builder. It will also be used by engine-side push code to create schema1 manifests from the new-style image configration, when necessary to push a schema1 manifest. Signed-off-by: Aaron Lehmann <aaron.lehmann@docker.com>
99 lines
2.3 KiB
Go
99 lines
2.3 KiB
Go
package schema1
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/docker/distribution/context"
|
|
"github.com/docker/distribution/digest"
|
|
"github.com/docker/distribution/manifest"
|
|
"github.com/docker/libtrust"
|
|
)
|
|
|
|
func makeSignedManifest(t *testing.T, pk libtrust.PrivateKey, refs []Reference) *SignedManifest {
|
|
u := &Manifest{
|
|
Versioned: manifest.Versioned{
|
|
SchemaVersion: 1,
|
|
},
|
|
Name: "foo/bar",
|
|
Tag: "latest",
|
|
Architecture: "amd64",
|
|
}
|
|
|
|
for i := len(refs) - 1; i >= 0; i-- {
|
|
u.FSLayers = append(u.FSLayers, FSLayer{
|
|
BlobSum: refs[i].Digest,
|
|
})
|
|
u.History = append(u.History, History{
|
|
V1Compatibility: refs[i].History.V1Compatibility,
|
|
})
|
|
}
|
|
|
|
signedManifest, err := Sign(u, pk)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error signing manifest: %v", err)
|
|
}
|
|
return signedManifest
|
|
}
|
|
|
|
func TestReferenceBuilder(t *testing.T) {
|
|
pk, err := libtrust.GenerateECP256PrivateKey()
|
|
if err != nil {
|
|
t.Fatalf("unexpected error generating private key: %v", err)
|
|
}
|
|
|
|
r1 := Reference{
|
|
Digest: "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
|
|
Size: 1,
|
|
History: History{V1Compatibility: "{\"a\" : 1 }"},
|
|
}
|
|
r2 := Reference{
|
|
Digest: "sha256:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
|
|
Size: 2,
|
|
History: History{V1Compatibility: "{\"\a\" : 2 }"},
|
|
}
|
|
|
|
handCrafted := makeSignedManifest(t, pk, []Reference{r1, r2})
|
|
|
|
b := NewReferenceManifestBuilder(pk, handCrafted.Manifest.Name, handCrafted.Manifest.Tag, handCrafted.Manifest.Architecture)
|
|
_, err = b.Build(context.Background())
|
|
if err == nil {
|
|
t.Fatal("Expected error building zero length manifest")
|
|
}
|
|
|
|
err = b.AppendReference(r1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = b.AppendReference(r2)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
refs := b.References()
|
|
if len(refs) != 2 {
|
|
t.Fatalf("Unexpected reference count : %d != %d", 2, len(refs))
|
|
}
|
|
|
|
// Ensure ordering
|
|
if refs[0].Digest != r2.Digest {
|
|
t.Fatalf("Unexpected reference : %v", refs[0])
|
|
}
|
|
|
|
m, err := b.Build(context.Background())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
built, ok := m.(*SignedManifest)
|
|
if !ok {
|
|
t.Fatalf("unexpected type from Build() : %T", built)
|
|
}
|
|
|
|
d1 := digest.FromBytes(built.Canonical)
|
|
d2 := digest.FromBytes(handCrafted.Canonical)
|
|
if d1 != d2 {
|
|
t.Errorf("mismatching canonical JSON")
|
|
}
|
|
}
|