This section is empty.


View Source
var (

	// ErrNoProcessor is returned when no stream processor is available for a media-type
	ErrNoProcessor = errors.New("no processor for media-type")


func RegisterProcessor

func RegisterProcessor(handler Handler)

    RegisterProcessor registers a stream processor for media-types


    type Applier

    type Applier interface {
    	// Apply applies the content referred to by the given descriptor to
    	// the provided mount. The method of applying is based on the
    	// implementation and content descriptor. For example, in the common
    	// case the descriptor is a file system difference in tar format,
    	// that tar would be applied on top of the mounts.
    	Apply(ctx context.Context, desc ocispec.Descriptor, mount []mount.Mount, opts ...ApplyOpt) (ocispec.Descriptor, error)

      Applier allows applying diffs between mounts

      type ApplyConfig

      type ApplyConfig struct {
      	// ProcessorPayloads specifies the payload sent to various processors
      	ProcessorPayloads map[string]*types.Any

        ApplyConfig is used to hold parameters needed for a apply operation

        type ApplyOpt

          ApplyOpt is used to configure an Apply operation

          func WithPayloads

          func WithPayloads(payloads map[string]*types.Any) ApplyOpt

            WithPayloads sets the apply processor payloads to the config

            type Comparer

            type Comparer interface {
            	// Compare computes the difference between two mounts and returns a
            	// descriptor for the computed diff. The options can provide
            	// a ref which can be used to track the content creation of the diff.
            	// The media type which is used to determine the format of the created
            	// content can also be provided as an option.
            	Compare(ctx context.Context, lower, upper []mount.Mount, opts ...Opt) (ocispec.Descriptor, error)

              Comparer allows creation of filesystem diffs between mounts

              type Config

              type Config struct {
              	// MediaType is the type of diff to generate
              	// Default depends on the differ,
              	// i.e. application/vnd.oci.image.layer.v1.tar+gzip
              	MediaType string
              	// Reference is the content upload reference
              	// Default will use a random reference string
              	Reference string
              	// Labels are the labels to apply to the generated content
              	Labels map[string]string

                Config is used to hold parameters needed for a diff operation

                type Handler

                type Handler func(ctx context.Context, mediaType string) (StreamProcessorInit, bool)

                  Handler checks a media-type and initializes the processor

                  func BinaryHandler

                  func BinaryHandler(id, returnsMediaType string, mediaTypes []string, path string, args []string) Handler

                  func StaticHandler

                  func StaticHandler(expectedMediaType string, fn StreamProcessorInit) Handler

                    StaticHandler returns the processor init func for a static media-type

                    type Opt

                    type Opt func(*Config) error

                      Opt is used to configure a diff operation

                      func WithLabels

                      func WithLabels(labels map[string]string) Opt

                        WithLabels is used to set content labels on the created diff content.

                        func WithMediaType

                        func WithMediaType(m string) Opt

                          WithMediaType sets the media type to use for creating the diff, without specifying the differ will choose a default.

                          func WithReference

                          func WithReference(ref string) Opt

                            WithReference is used to set the content upload reference used by the diff operation. This allows the caller to track the upload through the content store.

                            type RawProcessor

                            type RawProcessor interface {
                            	// File returns the fd for the read stream of the underlying processor
                            	File() *os.File

                              RawProcessor provides access to direct fd for processing

                              type StreamProcessor

                              type StreamProcessor interface {
                              	// MediaType is the resulting media-type that the processor processes the stream into
                              	MediaType() string

                                StreamProcessor handles processing a content stream and transforming it into a different media-type

                                func GetProcessor

                                func GetProcessor(ctx context.Context, stream StreamProcessor, payloads map[string]*types.Any) (StreamProcessor, error)

                                  GetProcessor returns the processor for a media-type

                                  func NewBinaryProcessor

                                  func NewBinaryProcessor(ctx context.Context, imt, rmt string, stream StreamProcessor, name string, args []string, payload *types.Any) (StreamProcessor, error)

                                    NewBinaryProcessor returns a binary processor for use with processing content streams

                                    func NewProcessorChain

                                    func NewProcessorChain(mt string, r io.Reader) StreamProcessor

                                      NewProcessorChain initialized the root StreamProcessor

                                      type StreamProcessorInit

                                      type StreamProcessorInit func(ctx context.Context, stream StreamProcessor, payloads map[string]*types.Any) (StreamProcessor, error)

                                        StreamProcessorInit returns the initialized stream processor


                                        Path Synopsis