mount.go

Documentation: github.com/google/go-containerregistry/pkg/v1/remote

     1  // Copyright 2018 Google LLC All Rights Reserved.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //    http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package remote
    16  
    17  import (
    18  	"github.com/google/go-containerregistry/pkg/name"
    19  	v1 "github.com/google/go-containerregistry/pkg/v1"
    20  	"github.com/google/go-containerregistry/pkg/v1/partial"
    21  )
    22  
    23  // MountableLayer wraps a v1.Layer in a shim that enables the layer to be
    24  // "mounted" when published to another registry.
    25  type MountableLayer struct {
    26  	v1.Layer
    27  
    28  	Reference name.Reference
    29  }
    30  
    31  // Descriptor retains the original descriptor from an image manifest.
    32  // See partial.Descriptor.
    33  func (ml *MountableLayer) Descriptor() (*v1.Descriptor, error) {
    34  	return partial.Descriptor(ml.Layer)
    35  }
    36  
    37  // Exists is a hack. See partial.Exists.
    38  func (ml *MountableLayer) Exists() (bool, error) {
    39  	return partial.Exists(ml.Layer)
    40  }
    41  
    42  // mountableImage wraps the v1.Layer references returned by the embedded v1.Image
    43  // in MountableLayer's so that remote.Write might attempt to mount them from their
    44  // source repository.
    45  type mountableImage struct {
    46  	v1.Image
    47  
    48  	Reference name.Reference
    49  }
    50  
    51  // Layers implements v1.Image
    52  func (mi *mountableImage) Layers() ([]v1.Layer, error) {
    53  	ls, err := mi.Image.Layers()
    54  	if err != nil {
    55  		return nil, err
    56  	}
    57  	mls := make([]v1.Layer, 0, len(ls))
    58  	for _, l := range ls {
    59  		mls = append(mls, &MountableLayer{
    60  			Layer:     l,
    61  			Reference: mi.Reference,
    62  		})
    63  	}
    64  	return mls, nil
    65  }
    66  
    67  // LayerByDigest implements v1.Image
    68  func (mi *mountableImage) LayerByDigest(d v1.Hash) (v1.Layer, error) {
    69  	l, err := mi.Image.LayerByDigest(d)
    70  	if err != nil {
    71  		return nil, err
    72  	}
    73  	return &MountableLayer{
    74  		Layer:     l,
    75  		Reference: mi.Reference,
    76  	}, nil
    77  }
    78  
    79  // LayerByDiffID implements v1.Image
    80  func (mi *mountableImage) LayerByDiffID(d v1.Hash) (v1.Layer, error) {
    81  	l, err := mi.Image.LayerByDiffID(d)
    82  	if err != nil {
    83  		return nil, err
    84  	}
    85  	return &MountableLayer{
    86  		Layer:     l,
    87  		Reference: mi.Reference,
    88  	}, nil
    89  }
    90  
    91  // Descriptor retains the original descriptor from an index manifest.
    92  // See partial.Descriptor.
    93  func (mi *mountableImage) Descriptor() (*v1.Descriptor, error) {
    94  	return partial.Descriptor(mi.Image)
    95  }
    96  
    97  // ConfigLayer retains the original reference so that it can be mounted.
    98  // See partial.ConfigLayer.
    99  func (mi *mountableImage) ConfigLayer() (v1.Layer, error) {
   100  	l, err := partial.ConfigLayer(mi.Image)
   101  	if err != nil {
   102  		return nil, err
   103  	}
   104  	return &MountableLayer{
   105  		Layer:     l,
   106  		Reference: mi.Reference,
   107  	}, nil
   108  }
   109
View as plain text