mirror of
https://github.com/mudler/luet.git
synced 2025-09-05 17:20:29 +00:00
Update gomod and vendor
This commit is contained in:
Ettore Di Giacinto
194
vendor/github.com/moby/buildkit/cache/blobs/blobs.go
generated
vendored
Normal file
194
vendor/github.com/moby/buildkit/cache/blobs/blobs.go
generated
vendored
Normal file
@@ -0,0 +1,194 @@
|
||||
package blobs
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"github.com/containerd/containerd/content"
|
||||
"github.com/containerd/containerd/diff"
|
||||
"github.com/containerd/containerd/leases"
|
||||
"github.com/containerd/containerd/mount"
|
||||
"github.com/moby/buildkit/cache"
|
||||
"github.com/moby/buildkit/util/flightcontrol"
|
||||
"github.com/moby/buildkit/util/winlayers"
|
||||
digest "github.com/opencontainers/go-digest"
|
||||
ocispec "github.com/opencontainers/image-spec/specs-go/v1"
|
||||
"github.com/pkg/errors"
|
||||
"golang.org/x/sync/errgroup"
|
||||
)
|
||||
|
||||
var g flightcontrol.Group
|
||||
|
||||
const containerdUncompressed = "containerd.io/uncompressed"
|
||||
|
||||
type DiffPair struct {
|
||||
DiffID digest.Digest
|
||||
Blobsum digest.Digest
|
||||
}
|
||||
|
||||
type CompareWithParent interface {
|
||||
CompareWithParent(ctx context.Context, ref string, opts ...diff.Opt) (ocispec.Descriptor, error)
|
||||
}
|
||||
|
||||
var ErrNoBlobs = errors.Errorf("no blobs for snapshot")
|
||||
|
||||
// GetDiffPairs returns the DiffID/Blobsum pairs for a giver reference and saves it.
|
||||
// Caller must hold a lease when calling this function.
|
||||
func GetDiffPairs(ctx context.Context, contentStore content.Store, differ diff.Comparer, ref cache.ImmutableRef, createBlobs bool, compression CompressionType) ([]DiffPair, error) {
|
||||
if ref == nil {
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
if _, ok := leases.FromContext(ctx); !ok {
|
||||
return nil, errors.Errorf("missing lease requirement for GetDiffPairs")
|
||||
}
|
||||
|
||||
if err := ref.Finalize(ctx, true); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if isTypeWindows(ref) {
|
||||
ctx = winlayers.UseWindowsLayerMode(ctx)
|
||||
}
|
||||
|
||||
return getDiffPairs(ctx, contentStore, differ, ref, createBlobs, compression)
|
||||
}
|
||||
|
||||
func getDiffPairs(ctx context.Context, contentStore content.Store, differ diff.Comparer, ref cache.ImmutableRef, createBlobs bool, compression CompressionType) ([]DiffPair, error) {
|
||||
if ref == nil {
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
baseCtx := ctx
|
||||
eg, ctx := errgroup.WithContext(ctx)
|
||||
var diffPairs []DiffPair
|
||||
var currentDescr ocispec.Descriptor
|
||||
parent := ref.Parent()
|
||||
if parent != nil {
|
||||
defer parent.Release(context.TODO())
|
||||
eg.Go(func() error {
|
||||
dp, err := getDiffPairs(ctx, contentStore, differ, parent, createBlobs, compression)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
diffPairs = dp
|
||||
return nil
|
||||
})
|
||||
}
|
||||
eg.Go(func() error {
|
||||
dp, err := g.Do(ctx, ref.ID(), func(ctx context.Context) (interface{}, error) {
|
||||
refInfo := ref.Info()
|
||||
if refInfo.Blob != "" {
|
||||
return nil, nil
|
||||
} else if !createBlobs {
|
||||
return nil, errors.WithStack(ErrNoBlobs)
|
||||
}
|
||||
|
||||
var mediaType string
|
||||
var descr ocispec.Descriptor
|
||||
var err error
|
||||
|
||||
switch compression {
|
||||
case Uncompressed:
|
||||
mediaType = ocispec.MediaTypeImageLayer
|
||||
case Gzip:
|
||||
mediaType = ocispec.MediaTypeImageLayerGzip
|
||||
default:
|
||||
return nil, errors.Errorf("unknown layer compression type")
|
||||
}
|
||||
|
||||
if pc, ok := differ.(CompareWithParent); ok {
|
||||
descr, err = pc.CompareWithParent(ctx, ref.ID(), diff.WithMediaType(mediaType))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
if descr.Digest == "" {
|
||||
// reference needs to be committed
|
||||
parent := ref.Parent()
|
||||
var lower []mount.Mount
|
||||
var release func() error
|
||||
if parent != nil {
|
||||
defer parent.Release(context.TODO())
|
||||
m, err := parent.Mount(ctx, true)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
lower, release, err = m.Mount()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if release != nil {
|
||||
defer release()
|
||||
}
|
||||
}
|
||||
m, err := ref.Mount(ctx, true)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
upper, release, err := m.Mount()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if release != nil {
|
||||
defer release()
|
||||
}
|
||||
descr, err = differ.Compare(ctx, lower, upper,
|
||||
diff.WithMediaType(mediaType),
|
||||
diff.WithReference(ref.ID()),
|
||||
)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
if descr.Annotations == nil {
|
||||
descr.Annotations = map[string]string{}
|
||||
}
|
||||
|
||||
info, err := contentStore.Info(ctx, descr.Digest)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if diffID, ok := info.Labels[containerdUncompressed]; ok {
|
||||
descr.Annotations[containerdUncompressed] = diffID
|
||||
} else if compression == Uncompressed {
|
||||
descr.Annotations[containerdUncompressed] = descr.Digest.String()
|
||||
} else {
|
||||
return nil, errors.Errorf("unknown layer compression type")
|
||||
}
|
||||
return descr, nil
|
||||
|
||||
})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if dp != nil {
|
||||
currentDescr = dp.(ocispec.Descriptor)
|
||||
}
|
||||
return nil
|
||||
})
|
||||
err := eg.Wait()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if currentDescr.Digest != "" {
|
||||
if err := ref.SetBlob(baseCtx, currentDescr); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
refInfo := ref.Info()
|
||||
return append(diffPairs, DiffPair{DiffID: refInfo.DiffID, Blobsum: refInfo.Blob}), nil
|
||||
}
|
||||
|
||||
func isTypeWindows(ref cache.ImmutableRef) bool {
|
||||
if cache.GetLayerType(ref) == "windows" {
|
||||
return true
|
||||
}
|
||||
if parent := ref.Parent(); parent != nil {
|
||||
defer parent.Release(context.TODO())
|
||||
return isTypeWindows(parent)
|
||||
}
|
||||
return false
|
||||
}
|
||||
122
vendor/github.com/moby/buildkit/cache/blobs/compression.go
generated
vendored
Normal file
122
vendor/github.com/moby/buildkit/cache/blobs/compression.go
generated
vendored
Normal file
@@ -0,0 +1,122 @@
|
||||
package blobs
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"io"
|
||||
|
||||
"github.com/containerd/containerd/content"
|
||||
"github.com/containerd/containerd/images"
|
||||
"github.com/moby/buildkit/cache"
|
||||
digest "github.com/opencontainers/go-digest"
|
||||
ocispec "github.com/opencontainers/image-spec/specs-go/v1"
|
||||
"github.com/pkg/errors"
|
||||
)
|
||||
|
||||
// CompressionType represents compression type for blob data.
|
||||
type CompressionType int
|
||||
|
||||
const (
|
||||
// Uncompressed indicates no compression.
|
||||
Uncompressed CompressionType = iota
|
||||
|
||||
// Gzip is used for blob data.
|
||||
Gzip
|
||||
|
||||
// UnknownCompression means not supported yet.
|
||||
UnknownCompression CompressionType = -1
|
||||
)
|
||||
|
||||
var DefaultCompression = Gzip
|
||||
|
||||
func (ct CompressionType) String() string {
|
||||
switch ct {
|
||||
case Uncompressed:
|
||||
return "uncompressed"
|
||||
case Gzip:
|
||||
return "gzip"
|
||||
default:
|
||||
return "unknown"
|
||||
}
|
||||
}
|
||||
|
||||
// DetectCompressionType returns media type from existing blob data.
|
||||
func DetectLayerMediaType(ctx context.Context, cs content.Store, id digest.Digest, oci bool) (string, error) {
|
||||
ra, err := cs.ReaderAt(ctx, ocispec.Descriptor{Digest: id})
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
defer ra.Close()
|
||||
|
||||
ct, err := detectCompressionType(content.NewReader(ra))
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
switch ct {
|
||||
case Uncompressed:
|
||||
if oci {
|
||||
return ocispec.MediaTypeImageLayer, nil
|
||||
} else {
|
||||
return images.MediaTypeDockerSchema2Layer, nil
|
||||
}
|
||||
case Gzip:
|
||||
if oci {
|
||||
return ocispec.MediaTypeImageLayerGzip, nil
|
||||
} else {
|
||||
return images.MediaTypeDockerSchema2LayerGzip, nil
|
||||
}
|
||||
default:
|
||||
return "", errors.Errorf("failed to detect layer %v compression type", id)
|
||||
}
|
||||
}
|
||||
|
||||
// detectCompressionType detects compression type from real blob data.
|
||||
func detectCompressionType(cr io.Reader) (CompressionType, error) {
|
||||
var buf [10]byte
|
||||
var n int
|
||||
var err error
|
||||
|
||||
if n, err = cr.Read(buf[:]); err != nil && err != io.EOF {
|
||||
// Note: we'll ignore any io.EOF error because there are some
|
||||
// odd cases where the layer.tar file will be empty (zero bytes)
|
||||
// and we'll just treat it as a non-compressed stream and that
|
||||
// means just create an empty layer.
|
||||
//
|
||||
// See issue docker/docker#18170
|
||||
return UnknownCompression, err
|
||||
}
|
||||
|
||||
for c, m := range map[CompressionType][]byte{
|
||||
Gzip: {0x1F, 0x8B, 0x08},
|
||||
} {
|
||||
if n < len(m) {
|
||||
continue
|
||||
}
|
||||
if bytes.Equal(m, buf[:len(m)]) {
|
||||
return c, nil
|
||||
}
|
||||
}
|
||||
return Uncompressed, nil
|
||||
}
|
||||
|
||||
// GetMediaTypeForLayers retrieves media type for layer from ref information.
|
||||
func GetMediaTypeForLayers(diffPairs []DiffPair, ref cache.ImmutableRef) []string {
|
||||
tref := ref
|
||||
|
||||
layerTypes := make([]string, 0, len(diffPairs))
|
||||
for _, dp := range diffPairs {
|
||||
if tref == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
info := tref.Info()
|
||||
if !(info.DiffID == dp.DiffID && info.Blob == dp.Blobsum) {
|
||||
return nil
|
||||
}
|
||||
|
||||
layerTypes = append(layerTypes, info.MediaType)
|
||||
tref = tref.Parent()
|
||||
}
|
||||
return layerTypes
|
||||
}
|
||||
Reference in New Issue
Block a user