Add schema2 manifest support

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>

manifest/schema1/reference_builder_test.go

@@ -0,0 +1,98 @@
+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")
+	}
+}