Debian Codegraph @

manifest/ocischema/manifest.go

raw
1 package ocischema
2
3 import (
4 "encoding/json"
5 "errors"
6 "fmt"
7
8 "github.com/docker/distribution"
9 "github.com/docker/distribution/manifest"
10 "github.com/opencontainers/go-digest"
11 v1 "github.com/opencontainers/image-spec/specs-go/v1"
12 )
13
14 var (
15 // SchemaVersion provides a pre-initialized version structure for this
16 // packages version of the manifest.
17 SchemaVersion = manifest.Versioned{
18 SchemaVersion: 2, // historical value here.. does not pertain to OCI or docker version
19 MediaType: v1.MediaTypeImageManifest,
20 }
21 )
22
23 func init() {
24 ocischemaFunc := func(b []byte) (distribution.Manifest, distribution.Descriptor, error) {
25 if err := validateManifest(b); err != nil {
26 return nil, distribution.Descriptor{}, err
27 }
28 m := new(DeserializedManifest)
29 err := m.UnmarshalJSON(b)
30 if err != nil {
31 return nil, distribution.Descriptor{}, err
32 }
33
34 dgst := digest.FromBytes(b)
35 return m, distribution.Descriptor{Digest: dgst, Size: int64(len(b)), MediaType: v1.MediaTypeImageManifest}, err
36 }
37 err := distribution.RegisterManifestSchema(v1.MediaTypeImageManifest, ocischemaFunc)
38 if err != nil {
39 panic(fmt.Sprintf("Unable to register manifest: %s", err))
40 }
41 }
42
43 // Manifest defines a ocischema manifest.
44 type Manifest struct {
45 manifest.Versioned
46
47 // Config references the image configuration as a blob.
48 Config distribution.Descriptor `json:"config"`
49
50 // Layers lists descriptors for the layers referenced by the
51 // configuration.
52 Layers []distribution.Descriptor `json:"layers"`
53
54 // Annotations contains arbitrary metadata for the image manifest.
55 Annotations map[string]string `json:"annotations,omitempty"`
56 }
57
58 // References returns the descriptors of this manifests references.
59 func (m Manifest) References() []distribution.Descriptor {
60 references := make([]distribution.Descriptor, 0, 1+len(m.Layers))
61 references = append(references, m.Config)
62 references = append(references, m.Layers...)
63 return references
64 }
65
66 // Target returns the target of this manifest.
67 func (m Manifest) Target() distribution.Descriptor {
68 return m.Config
69 }
70
71 // DeserializedManifest wraps Manifest with a copy of the original JSON.
72 // It satisfies the distribution.Manifest interface.
73 type DeserializedManifest struct {
74 Manifest
75
76 // canonical is the canonical byte representation of the Manifest.
77 canonical []byte
78 }
79
80 // FromStruct takes a Manifest structure, marshals it to JSON, and returns a
81 // DeserializedManifest which contains the manifest and its JSON representation.
82 func FromStruct(m Manifest) (*DeserializedManifest, error) {
83 var deserialized DeserializedManifest
84 deserialized.Manifest = m
85
86 var err error
87 deserialized.canonical, err = json.MarshalIndent(&m, "", " ")
88 return &deserialized, err
89 }
90
91 // UnmarshalJSON populates a new Manifest struct from JSON data.
92 func (m *DeserializedManifest) UnmarshalJSON(b []byte) error {
93 m.canonical = make([]byte, len(b))
94 // store manifest in canonical
95 copy(m.canonical, b)
96
97 // Unmarshal canonical JSON into Manifest object
98 var manifest Manifest
99 if err := json.Unmarshal(m.canonical, &manifest); err != nil {
100 return err
101 }
102
103 if manifest.MediaType != "" && manifest.MediaType != v1.MediaTypeImageManifest {
104 return fmt.Errorf("if present, mediaType in manifest should be '%s' not '%s'",
105 v1.MediaTypeImageManifest, manifest.MediaType)
106 }
107
108 m.Manifest = manifest
109
110 return nil
111 }
112
113 // MarshalJSON returns the contents of canonical. If canonical is empty,
114 // marshals the inner contents.
115 func (m *DeserializedManifest) MarshalJSON() ([]byte, error) {
116 if len(m.canonical) > 0 {
117 return m.canonical, nil
118 }
119
120 return nil, errors.New("JSON representation not initialized in DeserializedManifest")
121 }
122
123 // Payload returns the raw content of the manifest. The contents can be used to
124 // calculate the content identifier.
125 func (m DeserializedManifest) Payload() (string, []byte, error) {
126 return v1.MediaTypeImageManifest, m.canonical, nil
127 }
128
129 // unknownDocument represents a manifest, manifest list, or index that has not
130 // yet been validated
131 type unknownDocument struct {
132 Manifests interface{} `json:"manifests,omitempty"`
133 }
134
135 // validateManifest returns an error if the byte slice is invalid JSON or if it
136 // contains fields that belong to a index
137 func validateManifest(b []byte) error {
138 var doc unknownDocument
139 if err := json.Unmarshal(b, &doc); err != nil {
140 return err
141 }
142 if doc.Manifests != nil {
143 return errors.New("ocimanifest: expected manifest but found index")
144 }
145 return nil
146 }