mirror of
https://github.com/moby/moby.git
synced 2026-01-11 18:51:37 +00:00
remove deprecated pkg/archive, pkg/chrootarchive
These packages were deprecated in 57a042b77c
(v28.1.0), and moved to a separate module.
Signed-off-by: Sebastiaan van Stijn <github@gone.nl>
This commit is contained in:
Sebastiaan van Stijn
@@ -1,259 +0,0 @@
|
||||
// Package archive provides helper functions for dealing with archive files.
|
||||
package archive
|
||||
|
||||
import (
|
||||
"archive/tar"
|
||||
"io"
|
||||
"os"
|
||||
|
||||
"github.com/docker/docker/pkg/idtools"
|
||||
"github.com/moby/go-archive"
|
||||
"github.com/moby/go-archive/compression"
|
||||
"github.com/moby/go-archive/tarheader"
|
||||
)
|
||||
|
||||
// ImpliedDirectoryMode represents the mode (Unix permissions) applied to directories that are implied by files in a
|
||||
// tar, but that do not have their own header entry.
|
||||
//
|
||||
// Deprecated: use [archive.ImpliedDirectoryMode] instead.
|
||||
const ImpliedDirectoryMode = archive.ImpliedDirectoryMode
|
||||
|
||||
type (
|
||||
// Compression is the state represents if compressed or not.
|
||||
//
|
||||
// Deprecated: use [compression.Compression] instead.
|
||||
Compression = compression.Compression
|
||||
// WhiteoutFormat is the format of whiteouts unpacked
|
||||
//
|
||||
// Deprecated: use [archive.WhiteoutFormat] instead.
|
||||
WhiteoutFormat = archive.WhiteoutFormat
|
||||
|
||||
// TarOptions wraps the tar options.
|
||||
//
|
||||
// Deprecated: use [archive.TarOptions] instead.
|
||||
TarOptions struct {
|
||||
IncludeFiles []string
|
||||
ExcludePatterns []string
|
||||
Compression compression.Compression
|
||||
NoLchown bool
|
||||
IDMap idtools.IdentityMapping
|
||||
ChownOpts *idtools.Identity
|
||||
IncludeSourceDir bool
|
||||
// WhiteoutFormat is the expected on disk format for whiteout files.
|
||||
// This format will be converted to the standard format on pack
|
||||
// and from the standard format on unpack.
|
||||
WhiteoutFormat archive.WhiteoutFormat
|
||||
// When unpacking, specifies whether overwriting a directory with a
|
||||
// non-directory is allowed and vice versa.
|
||||
NoOverwriteDirNonDir bool
|
||||
// For each include when creating an archive, the included name will be
|
||||
// replaced with the matching name from this map.
|
||||
RebaseNames map[string]string
|
||||
InUserNS bool
|
||||
// Allow unpacking to succeed in spite of failures to set extended
|
||||
// attributes on the unpacked files due to the destination filesystem
|
||||
// not supporting them or a lack of permissions. Extended attributes
|
||||
// were probably in the archive for a reason, so set this option at
|
||||
// your own peril.
|
||||
BestEffortXattrs bool
|
||||
}
|
||||
)
|
||||
|
||||
// Archiver implements the Archiver interface and allows the reuse of most utility functions of
|
||||
// this package with a pluggable Untar function. Also, to facilitate the passing of specific id
|
||||
// mappings for untar, an Archiver can be created with maps which will then be passed to Untar operations.
|
||||
//
|
||||
// Deprecated: use [archive.Archiver] instead.
|
||||
type Archiver struct {
|
||||
Untar func(io.Reader, string, *TarOptions) error
|
||||
IDMapping idtools.IdentityMapping
|
||||
}
|
||||
|
||||
// NewDefaultArchiver returns a new Archiver without any IdentityMapping
|
||||
//
|
||||
// Deprecated: use [archive.NewDefaultArchiver] instead.
|
||||
func NewDefaultArchiver() *Archiver {
|
||||
return &Archiver{Untar: Untar}
|
||||
}
|
||||
|
||||
const (
|
||||
Uncompressed = compression.None // Deprecated: use [compression.None] instead.
|
||||
Bzip2 = compression.Bzip2 // Deprecated: use [compression.Bzip2] instead.
|
||||
Gzip = compression.Gzip // Deprecated: use [compression.Gzip] instead.
|
||||
Xz = compression.Xz // Deprecated: use [compression.Xz] instead.
|
||||
Zstd = compression.Zstd // Deprecated: use [compression.Zstd] instead.
|
||||
)
|
||||
|
||||
const (
|
||||
AUFSWhiteoutFormat = archive.AUFSWhiteoutFormat // Deprecated: use [archive.AUFSWhiteoutFormat] instead.
|
||||
OverlayWhiteoutFormat = archive.OverlayWhiteoutFormat // Deprecated: use [archive.OverlayWhiteoutFormat] instead.
|
||||
)
|
||||
|
||||
// IsArchivePath checks if the (possibly compressed) file at the given path
|
||||
// starts with a tar file header.
|
||||
//
|
||||
// Deprecated: use [archive.IsArchivePath] instead.
|
||||
func IsArchivePath(path string) bool {
|
||||
return archive.IsArchivePath(path)
|
||||
}
|
||||
|
||||
// DetectCompression detects the compression algorithm of the source.
|
||||
//
|
||||
// Deprecated: use [compression.Detect] instead.
|
||||
func DetectCompression(source []byte) archive.Compression {
|
||||
return compression.Detect(source)
|
||||
}
|
||||
|
||||
// DecompressStream decompresses the archive and returns a ReaderCloser with the decompressed archive.
|
||||
//
|
||||
// Deprecated: use [compression.DecompressStream] instead.
|
||||
func DecompressStream(arch io.Reader) (io.ReadCloser, error) {
|
||||
return compression.DecompressStream(arch)
|
||||
}
|
||||
|
||||
// CompressStream compresses the dest with specified compression algorithm.
|
||||
//
|
||||
// Deprecated: use [compression.CompressStream] instead.
|
||||
func CompressStream(dest io.Writer, comp compression.Compression) (io.WriteCloser, error) {
|
||||
return compression.CompressStream(dest, comp)
|
||||
}
|
||||
|
||||
// TarModifierFunc is a function that can be passed to ReplaceFileTarWrapper.
|
||||
//
|
||||
// Deprecated: use [archive.TarModifierFunc] instead.
|
||||
type TarModifierFunc = archive.TarModifierFunc
|
||||
|
||||
// ReplaceFileTarWrapper converts inputTarStream to a new tar stream.
|
||||
//
|
||||
// Deprecated: use [archive.ReplaceFileTarWrapper] instead.
|
||||
func ReplaceFileTarWrapper(inputTarStream io.ReadCloser, mods map[string]archive.TarModifierFunc) io.ReadCloser {
|
||||
return archive.ReplaceFileTarWrapper(inputTarStream, mods)
|
||||
}
|
||||
|
||||
// FileInfoHeaderNoLookups creates a partially-populated tar.Header from fi.
|
||||
//
|
||||
// Deprecated: use [tarheader.FileInfoHeaderNoLookups] instead.
|
||||
func FileInfoHeaderNoLookups(fi os.FileInfo, link string) (*tar.Header, error) {
|
||||
return tarheader.FileInfoHeaderNoLookups(fi, link)
|
||||
}
|
||||
|
||||
// FileInfoHeader creates a populated Header from fi.
|
||||
//
|
||||
// Deprecated: use [archive.FileInfoHeader] instead.
|
||||
func FileInfoHeader(name string, fi os.FileInfo, link string) (*tar.Header, error) {
|
||||
return archive.FileInfoHeader(name, fi, link)
|
||||
}
|
||||
|
||||
// ReadSecurityXattrToTarHeader reads security.capability xattr from filesystem
|
||||
// to a tar header
|
||||
//
|
||||
// Deprecated: use [archive.ReadSecurityXattrToTarHeader] instead.
|
||||
func ReadSecurityXattrToTarHeader(path string, hdr *tar.Header) error {
|
||||
return archive.ReadSecurityXattrToTarHeader(path, hdr)
|
||||
}
|
||||
|
||||
// Tar creates an archive from the directory at `path`, and returns it as a
|
||||
// stream of bytes.
|
||||
//
|
||||
// Deprecated: use [archive.Tar] instead.
|
||||
func Tar(path string, compression archive.Compression) (io.ReadCloser, error) {
|
||||
return archive.TarWithOptions(path, &archive.TarOptions{Compression: compression})
|
||||
}
|
||||
|
||||
// TarWithOptions creates an archive with the given options.
|
||||
//
|
||||
// Deprecated: use [archive.TarWithOptions] instead.
|
||||
func TarWithOptions(srcPath string, options *TarOptions) (io.ReadCloser, error) {
|
||||
return archive.TarWithOptions(srcPath, toArchiveOpt(options))
|
||||
}
|
||||
|
||||
// Tarballer is a lower-level interface to TarWithOptions.
|
||||
//
|
||||
// Deprecated: use [archive.Tarballer] instead.
|
||||
type Tarballer = archive.Tarballer
|
||||
|
||||
// NewTarballer constructs a new tarballer using TarWithOptions.
|
||||
//
|
||||
// Deprecated: use [archive.Tarballer] instead.
|
||||
func NewTarballer(srcPath string, options *TarOptions) (*archive.Tarballer, error) {
|
||||
return archive.NewTarballer(srcPath, toArchiveOpt(options))
|
||||
}
|
||||
|
||||
// Unpack unpacks the decompressedArchive to dest with options.
|
||||
//
|
||||
// Deprecated: use [archive.Unpack] instead.
|
||||
func Unpack(decompressedArchive io.Reader, dest string, options *TarOptions) error {
|
||||
return archive.Unpack(decompressedArchive, dest, toArchiveOpt(options))
|
||||
}
|
||||
|
||||
// Untar reads a stream of bytes from `archive`, parses it as a tar archive,
|
||||
// and unpacks it into the directory at `dest`.
|
||||
//
|
||||
// Deprecated: use [archive.Untar] instead.
|
||||
func Untar(tarArchive io.Reader, dest string, options *TarOptions) error {
|
||||
return archive.Untar(tarArchive, dest, toArchiveOpt(options))
|
||||
}
|
||||
|
||||
// UntarUncompressed reads a stream of bytes from `tarArchive`, parses it as a tar archive,
|
||||
// and unpacks it into the directory at `dest`.
|
||||
// The archive must be an uncompressed stream.
|
||||
//
|
||||
// Deprecated: use [archive.UntarUncompressed] instead.
|
||||
func UntarUncompressed(tarArchive io.Reader, dest string, options *TarOptions) error {
|
||||
return archive.UntarUncompressed(tarArchive, dest, toArchiveOpt(options))
|
||||
}
|
||||
|
||||
// TarUntar is a convenience function which calls Tar and Untar, with the output of one piped into the other.
|
||||
// If either Tar or Untar fails, TarUntar aborts and returns the error.
|
||||
func (archiver *Archiver) TarUntar(src, dst string) error {
|
||||
return (&archive.Archiver{
|
||||
Untar: func(reader io.Reader, s string, options *archive.TarOptions) error {
|
||||
return archiver.Untar(reader, s, &TarOptions{
|
||||
IDMap: archiver.IDMapping,
|
||||
})
|
||||
},
|
||||
IDMapping: idtools.ToUserIdentityMapping(archiver.IDMapping),
|
||||
}).TarUntar(src, dst)
|
||||
}
|
||||
|
||||
// UntarPath untar a file from path to a destination, src is the source tar file path.
|
||||
func (archiver *Archiver) UntarPath(src, dst string) error {
|
||||
return (&archive.Archiver{
|
||||
Untar: func(reader io.Reader, s string, options *archive.TarOptions) error {
|
||||
return archiver.Untar(reader, s, &TarOptions{
|
||||
IDMap: archiver.IDMapping,
|
||||
})
|
||||
},
|
||||
IDMapping: idtools.ToUserIdentityMapping(archiver.IDMapping),
|
||||
}).UntarPath(src, dst)
|
||||
}
|
||||
|
||||
// CopyWithTar creates a tar archive of filesystem path `src`, and
|
||||
// unpacks it at filesystem path `dst`.
|
||||
// The archive is streamed directly with fixed buffering and no
|
||||
// intermediary disk IO.
|
||||
func (archiver *Archiver) CopyWithTar(src, dst string) error {
|
||||
return (&archive.Archiver{
|
||||
Untar: func(reader io.Reader, s string, options *archive.TarOptions) error {
|
||||
return archiver.Untar(reader, s, nil)
|
||||
},
|
||||
IDMapping: idtools.ToUserIdentityMapping(archiver.IDMapping),
|
||||
}).CopyWithTar(src, dst)
|
||||
}
|
||||
|
||||
// CopyFileWithTar emulates the behavior of the 'cp' command-line
|
||||
// for a single file. It copies a regular file from path `src` to
|
||||
// path `dst`, and preserves all its metadata.
|
||||
func (archiver *Archiver) CopyFileWithTar(src, dst string) (err error) {
|
||||
return (&archive.Archiver{
|
||||
Untar: func(reader io.Reader, s string, options *archive.TarOptions) error {
|
||||
return archiver.Untar(reader, s, nil)
|
||||
},
|
||||
IDMapping: idtools.ToUserIdentityMapping(archiver.IDMapping),
|
||||
}).CopyFileWithTar(src, dst)
|
||||
}
|
||||
|
||||
// IdentityMapping returns the IdentityMapping of the archiver.
|
||||
func (archiver *Archiver) IdentityMapping() idtools.IdentityMapping {
|
||||
return archiver.IDMapping
|
||||
}
|
||||
@@ -1,56 +0,0 @@
|
||||
package archive
|
||||
|
||||
import (
|
||||
"io"
|
||||
|
||||
"github.com/docker/docker/pkg/idtools"
|
||||
"github.com/moby/go-archive"
|
||||
)
|
||||
|
||||
// ChangeType represents the change
|
||||
//
|
||||
// Deprecated: use [archive.ChangeType] instead.
|
||||
type ChangeType = archive.ChangeType
|
||||
|
||||
const (
|
||||
ChangeModify = archive.ChangeModify // Deprecated: use [archive.ChangeModify] instead.
|
||||
ChangeAdd = archive.ChangeAdd // Deprecated: use [archive.ChangeAdd] instead.
|
||||
ChangeDelete = archive.ChangeDelete // Deprecated: use [archive.ChangeDelete] instead.
|
||||
)
|
||||
|
||||
// Change represents a change.
|
||||
//
|
||||
// Deprecated: use [archive.Change] instead.
|
||||
type Change = archive.Change
|
||||
|
||||
// Changes walks the path rw and determines changes for the files in the path,
|
||||
// with respect to the parent layers
|
||||
//
|
||||
// Deprecated: use [archive.Changes] instead.
|
||||
func Changes(layers []string, rw string) ([]archive.Change, error) {
|
||||
return archive.Changes(layers, rw)
|
||||
}
|
||||
|
||||
// FileInfo describes the information of a file.
|
||||
//
|
||||
// Deprecated: use [archive.FileInfo] instead.
|
||||
type FileInfo = archive.FileInfo
|
||||
|
||||
// ChangesDirs compares two directories and generates an array of Change objects describing the changes.
|
||||
//
|
||||
// Deprecated: use [archive.ChangesDirs] instead.
|
||||
func ChangesDirs(newDir, oldDir string) ([]archive.Change, error) {
|
||||
return archive.ChangesDirs(newDir, oldDir)
|
||||
}
|
||||
|
||||
// ChangesSize calculates the size in bytes of the provided changes, based on newDir.
|
||||
//
|
||||
// Deprecated: use [archive.ChangesSize] instead.
|
||||
func ChangesSize(newDir string, changes []archive.Change) int64 {
|
||||
return archive.ChangesSize(newDir, changes)
|
||||
}
|
||||
|
||||
// ExportChanges produces an Archive from the provided changes, relative to dir.
|
||||
func ExportChanges(dir string, changes []archive.Change, idMap idtools.IdentityMapping) (io.ReadCloser, error) {
|
||||
return archive.ExportChanges(dir, changes, idtools.ToUserIdentityMapping(idMap))
|
||||
}
|
||||
@@ -1,130 +0,0 @@
|
||||
package archive
|
||||
|
||||
import (
|
||||
"io"
|
||||
|
||||
"github.com/moby/go-archive"
|
||||
"github.com/moby/go-archive/compression"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrNotDirectory = archive.ErrNotDirectory // Deprecated: use [archive.ErrNotDirectory] instead.
|
||||
ErrDirNotExists = archive.ErrDirNotExists // Deprecated: use [archive.ErrDirNotExists] instead.
|
||||
ErrCannotCopyDir = archive.ErrCannotCopyDir // Deprecated: use [archive.ErrCannotCopyDir] instead.
|
||||
ErrInvalidCopySource = archive.ErrInvalidCopySource // Deprecated: use [archive.ErrInvalidCopySource] instead.
|
||||
)
|
||||
|
||||
// PreserveTrailingDotOrSeparator returns the given cleaned path.
|
||||
//
|
||||
// Deprecated: use [archive.PreserveTrailingDotOrSeparator] instead.
|
||||
func PreserveTrailingDotOrSeparator(cleanedPath string, originalPath string) string {
|
||||
return archive.PreserveTrailingDotOrSeparator(cleanedPath, originalPath)
|
||||
}
|
||||
|
||||
// SplitPathDirEntry splits the given path between its directory name and its
|
||||
// basename.
|
||||
//
|
||||
// Deprecated: use [archive.SplitPathDirEntry] instead.
|
||||
func SplitPathDirEntry(path string) (dir, base string) {
|
||||
return archive.SplitPathDirEntry(path)
|
||||
}
|
||||
|
||||
// TarResource archives the resource described by the given CopyInfo to a Tar
|
||||
// archive.
|
||||
//
|
||||
// Deprecated: use [archive.TarResource] instead.
|
||||
func TarResource(sourceInfo archive.CopyInfo) (content io.ReadCloser, err error) {
|
||||
return archive.TarResource(sourceInfo)
|
||||
}
|
||||
|
||||
// TarResourceRebase is like TarResource but renames the first path element of
|
||||
// items in the resulting tar archive to match the given rebaseName if not "".
|
||||
//
|
||||
// Deprecated: use [archive.TarResourceRebase] instead.
|
||||
func TarResourceRebase(sourcePath, rebaseName string) (content io.ReadCloser, _ error) {
|
||||
return archive.TarResourceRebase(sourcePath, rebaseName)
|
||||
}
|
||||
|
||||
// TarResourceRebaseOpts does not preform the Tar, but instead just creates the rebase
|
||||
// parameters to be sent to TarWithOptions.
|
||||
//
|
||||
// Deprecated: use [archive.TarResourceRebaseOpts] instead.
|
||||
func TarResourceRebaseOpts(sourceBase string, rebaseName string) *TarOptions {
|
||||
filter := []string{sourceBase}
|
||||
return &TarOptions{
|
||||
Compression: compression.None,
|
||||
IncludeFiles: filter,
|
||||
IncludeSourceDir: true,
|
||||
RebaseNames: map[string]string{
|
||||
sourceBase: rebaseName,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// CopyInfo holds basic info about the source or destination path of a copy operation.
|
||||
//
|
||||
// Deprecated: use [archive.CopyInfo] instead.
|
||||
type CopyInfo = archive.CopyInfo
|
||||
|
||||
// CopyInfoSourcePath stats the given path to create a CopyInfo struct.
|
||||
// struct representing that resource for the source of an archive copy
|
||||
// operation.
|
||||
//
|
||||
// Deprecated: use [archive.CopyInfoSourcePath] instead.
|
||||
func CopyInfoSourcePath(path string, followLink bool) (archive.CopyInfo, error) {
|
||||
return archive.CopyInfoSourcePath(path, followLink)
|
||||
}
|
||||
|
||||
// CopyInfoDestinationPath stats the given path to create a CopyInfo
|
||||
// struct representing that resource for the destination of an archive copy
|
||||
// operation.
|
||||
//
|
||||
// Deprecated: use [archive.CopyInfoDestinationPath] instead.
|
||||
func CopyInfoDestinationPath(path string) (info archive.CopyInfo, err error) {
|
||||
return archive.CopyInfoDestinationPath(path)
|
||||
}
|
||||
|
||||
// PrepareArchiveCopy prepares the given srcContent archive.
|
||||
//
|
||||
// Deprecated: use [archive.PrepareArchiveCopy] instead.
|
||||
func PrepareArchiveCopy(srcContent io.Reader, srcInfo, dstInfo archive.CopyInfo) (dstDir string, content io.ReadCloser, err error) {
|
||||
return archive.PrepareArchiveCopy(srcContent, srcInfo, dstInfo)
|
||||
}
|
||||
|
||||
// RebaseArchiveEntries rewrites the given srcContent archive replacing
|
||||
// an occurrence of oldBase with newBase at the beginning of entry names.
|
||||
//
|
||||
// Deprecated: use [archive.RebaseArchiveEntries] instead.
|
||||
func RebaseArchiveEntries(srcContent io.Reader, oldBase, newBase string) io.ReadCloser {
|
||||
return archive.RebaseArchiveEntries(srcContent, oldBase, newBase)
|
||||
}
|
||||
|
||||
// CopyResource performs an archive copy from the given source path to the
|
||||
// given destination path.
|
||||
//
|
||||
// Deprecated: use [archive.CopyResource] instead.
|
||||
func CopyResource(srcPath, dstPath string, followLink bool) error {
|
||||
return archive.CopyResource(srcPath, dstPath, followLink)
|
||||
}
|
||||
|
||||
// CopyTo handles extracting the given content whose
|
||||
// entries should be sourced from srcInfo to dstPath.
|
||||
//
|
||||
// Deprecated: use [archive.CopyTo] instead.
|
||||
func CopyTo(content io.Reader, srcInfo archive.CopyInfo, dstPath string) error {
|
||||
return archive.CopyTo(content, srcInfo, dstPath)
|
||||
}
|
||||
|
||||
// ResolveHostSourcePath decides real path need to be copied.
|
||||
//
|
||||
// Deprecated: use [archive.ResolveHostSourcePath] instead.
|
||||
func ResolveHostSourcePath(path string, followLink bool) (resolvedPath, rebaseName string, _ error) {
|
||||
return archive.ResolveHostSourcePath(path, followLink)
|
||||
}
|
||||
|
||||
// GetRebaseName normalizes and compares path and resolvedPath.
|
||||
//
|
||||
// Deprecated: use [archive.GetRebaseName] instead.
|
||||
func GetRebaseName(path, resolvedPath string) (string, string) {
|
||||
return archive.GetRebaseName(path, resolvedPath)
|
||||
}
|
||||
@@ -1,37 +0,0 @@
|
||||
package archive
|
||||
|
||||
import (
|
||||
"io"
|
||||
|
||||
"github.com/moby/go-archive"
|
||||
)
|
||||
|
||||
// UnpackLayer unpack `layer` to a `dest`.
|
||||
//
|
||||
// Deprecated: use [archive.UnpackLayer] instead.
|
||||
func UnpackLayer(dest string, layer io.Reader, options *TarOptions) (size int64, err error) {
|
||||
return archive.UnpackLayer(dest, layer, toArchiveOpt(options))
|
||||
}
|
||||
|
||||
// ApplyLayer parses a diff in the standard layer format from `layer`,
|
||||
// and applies it to the directory `dest`.
|
||||
//
|
||||
// Deprecated: use [archive.ApplyLayer] instead.
|
||||
func ApplyLayer(dest string, layer io.Reader) (int64, error) {
|
||||
return archive.ApplyLayer(dest, layer)
|
||||
}
|
||||
|
||||
// ApplyUncompressedLayer parses a diff in the standard layer format from
|
||||
// `layer`, and applies it to the directory `dest`.
|
||||
//
|
||||
// Deprecated: use [archive.ApplyUncompressedLayer] instead.
|
||||
func ApplyUncompressedLayer(dest string, layer io.Reader, options *TarOptions) (int64, error) {
|
||||
return archive.ApplyUncompressedLayer(dest, layer, toArchiveOpt(options))
|
||||
}
|
||||
|
||||
// IsEmpty checks if the tar archive is empty (doesn't contain any entries).
|
||||
//
|
||||
// Deprecated: use [archive.IsEmpty] instead.
|
||||
func IsEmpty(rd io.Reader) (bool, error) {
|
||||
return archive.IsEmpty(rd)
|
||||
}
|
||||
@@ -1,10 +0,0 @@
|
||||
package archive
|
||||
|
||||
import "github.com/moby/go-archive"
|
||||
|
||||
// CheckSystemDriveAndRemoveDriveLetter verifies that a path is the system drive.
|
||||
//
|
||||
// Deprecated: use [archive.CheckSystemDriveAndRemoveDriveLetter] instead.
|
||||
func CheckSystemDriveAndRemoveDriveLetter(path string) (string, error) {
|
||||
return archive.CheckSystemDriveAndRemoveDriveLetter(path)
|
||||
}
|
||||
@@ -1,42 +0,0 @@
|
||||
package archive
|
||||
|
||||
import (
|
||||
"github.com/docker/docker/pkg/idtools"
|
||||
"github.com/moby/go-archive"
|
||||
)
|
||||
|
||||
// ToArchiveOpt converts an [TarOptions] to a [archive.TarOptions].
|
||||
//
|
||||
// Deprecated: use [archive.TarOptions] instead, this utility is for internal use to transition to the [github.com/moby/go-archive] module.
|
||||
func ToArchiveOpt(options *TarOptions) *archive.TarOptions {
|
||||
return toArchiveOpt(options)
|
||||
}
|
||||
|
||||
func toArchiveOpt(options *TarOptions) *archive.TarOptions {
|
||||
if options == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
var chownOpts *archive.ChownOpts
|
||||
if options.ChownOpts != nil {
|
||||
chownOpts = &archive.ChownOpts{
|
||||
UID: options.ChownOpts.UID,
|
||||
GID: options.ChownOpts.GID,
|
||||
}
|
||||
}
|
||||
|
||||
return &archive.TarOptions{
|
||||
IncludeFiles: options.IncludeFiles,
|
||||
ExcludePatterns: options.ExcludePatterns,
|
||||
Compression: options.Compression,
|
||||
NoLchown: options.NoLchown,
|
||||
IDMap: idtools.ToUserIdentityMapping(options.IDMap),
|
||||
ChownOpts: chownOpts,
|
||||
IncludeSourceDir: options.IncludeSourceDir,
|
||||
WhiteoutFormat: options.WhiteoutFormat,
|
||||
NoOverwriteDirNonDir: options.NoOverwriteDirNonDir,
|
||||
RebaseNames: options.RebaseNames,
|
||||
InUserNS: options.InUserNS,
|
||||
BestEffortXattrs: options.BestEffortXattrs,
|
||||
}
|
||||
}
|
||||
@@ -1,10 +0,0 @@
|
||||
package archive
|
||||
|
||||
import "github.com/moby/go-archive"
|
||||
|
||||
const (
|
||||
WhiteoutPrefix = archive.WhiteoutPrefix // Deprecated: use [archive.WhiteoutPrefix] instead.
|
||||
WhiteoutMetaPrefix = archive.WhiteoutMetaPrefix // Deprecated: use [archive.WhiteoutMetaPrefix] instead.
|
||||
WhiteoutLinkDir = archive.WhiteoutLinkDir // Deprecated: use [archive.WhiteoutLinkDir] instead.
|
||||
WhiteoutOpaqueDir = archive.WhiteoutOpaqueDir // Deprecated: use [archive.WhiteoutOpaqueDir] instead.
|
||||
)
|
||||
@@ -1,14 +0,0 @@
|
||||
package archive
|
||||
|
||||
import (
|
||||
"io"
|
||||
|
||||
"github.com/moby/go-archive"
|
||||
)
|
||||
|
||||
// Generate generates a new archive from the content provided as input.
|
||||
//
|
||||
// Deprecated: use [archive.Generate] instead.
|
||||
func Generate(input ...string) (io.Reader, error) {
|
||||
return archive.Generate(input...)
|
||||
}
|
||||
@@ -1,49 +0,0 @@
|
||||
package chrootarchive
|
||||
|
||||
import (
|
||||
"io"
|
||||
|
||||
"github.com/docker/docker/pkg/archive"
|
||||
"github.com/docker/docker/pkg/idtools"
|
||||
"github.com/moby/go-archive/chrootarchive"
|
||||
)
|
||||
|
||||
// NewArchiver returns a new Archiver which uses chrootarchive.Untar
|
||||
//
|
||||
// Deprecated: use [chrootarchive.NewArchiver] instead.
|
||||
func NewArchiver(idMapping idtools.IdentityMapping) *archive.Archiver {
|
||||
return &archive.Archiver{
|
||||
Untar: Untar,
|
||||
IDMapping: idMapping,
|
||||
}
|
||||
}
|
||||
|
||||
// Untar reads a stream of bytes from `archive`, parses it as a tar archive,
|
||||
// and unpacks it into the directory at `dest`.
|
||||
//
|
||||
// Deprecated: use [chrootarchive.Untar] instead.
|
||||
func Untar(tarArchive io.Reader, dest string, options *archive.TarOptions) error {
|
||||
return chrootarchive.Untar(tarArchive, dest, archive.ToArchiveOpt(options))
|
||||
}
|
||||
|
||||
// UntarWithRoot is the same as [Untar], but allows you to pass in a root directory.
|
||||
//
|
||||
// Deprecated: use [chrootarchive.UntarWithRoot] instead.
|
||||
func UntarWithRoot(tarArchive io.Reader, dest string, options *archive.TarOptions, root string) error {
|
||||
return chrootarchive.UntarWithRoot(tarArchive, dest, archive.ToArchiveOpt(options), root)
|
||||
}
|
||||
|
||||
// UntarUncompressed reads a stream of bytes from tarArchive, parses it as a tar archive,
|
||||
// and unpacks it into the directory at dest.
|
||||
//
|
||||
// Deprecated: use [chrootarchive.UntarUncompressed] instead.
|
||||
func UntarUncompressed(tarArchive io.Reader, dest string, options *archive.TarOptions) error {
|
||||
return chrootarchive.UntarUncompressed(tarArchive, dest, archive.ToArchiveOpt(options))
|
||||
}
|
||||
|
||||
// Tar tars the requested path while chrooted to the specified root.
|
||||
//
|
||||
// Deprecated: use [chrootarchive.Tar] instead.
|
||||
func Tar(srcPath string, options *archive.TarOptions, root string) (io.ReadCloser, error) {
|
||||
return chrootarchive.Tar(srcPath, archive.ToArchiveOpt(options), root)
|
||||
}
|
||||
@@ -1,24 +0,0 @@
|
||||
package chrootarchive
|
||||
|
||||
import (
|
||||
"io"
|
||||
|
||||
"github.com/docker/docker/pkg/archive"
|
||||
"github.com/moby/go-archive/chrootarchive"
|
||||
)
|
||||
|
||||
// ApplyLayer parses a diff in the standard layer format from `layer`,
|
||||
// and applies it to the directory `dest`.
|
||||
//
|
||||
// Deprecated: use [chrootarchive.ApplyLayer] insteead.
|
||||
func ApplyLayer(dest string, layer io.Reader) (size int64, err error) {
|
||||
return chrootarchive.ApplyLayer(dest, layer)
|
||||
}
|
||||
|
||||
// ApplyUncompressedLayer parses a diff in the standard layer format from
|
||||
// `layer`, and applies it to the directory `dest`.
|
||||
//
|
||||
// Deprecated: use [chrootarchive.ApplyUncompressedLayer] insteead.
|
||||
func ApplyUncompressedLayer(dest string, layer io.Reader, options *archive.TarOptions) (int64, error) {
|
||||
return chrootarchive.ApplyUncompressedLayer(dest, layer, archive.ToArchiveOpt(options))
|
||||
}
|
||||
Reference in New Issue
Block a user