manifest.go

Documentation: github.com/docker/distribution/manifest/ocischema

     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  }
   147
View as plain text