110 lines
3.7 KiB
Go
110 lines
3.7 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/containers/storage"
|
|
"github.com/containers/storage/pkg/chrootarchive"
|
|
"github.com/containers/storage/pkg/idtools"
|
|
"github.com/containers/storage/pkg/mflag"
|
|
)
|
|
|
|
var chownOptions = ""
|
|
|
|
func copyContent(flags *mflag.FlagSet, action string, m storage.Store, args []string) (int, error) {
|
|
var untarIDMappings *idtools.IDMappings
|
|
var chownOpts *idtools.IDPair
|
|
if len(args) < 1 {
|
|
return 1, nil
|
|
}
|
|
if len(chownOptions) > 0 {
|
|
chownParts := strings.SplitN(chownOptions, ":", 2)
|
|
if len(chownParts) == 1 {
|
|
chownParts = append(chownParts, chownParts[0])
|
|
}
|
|
uid, err := strconv.ParseUint(chownParts[0], 10, 32)
|
|
if err != nil {
|
|
return 1, fmt.Errorf("error %q as a numeric UID: %v", chownParts[0], err)
|
|
}
|
|
gid, err := strconv.ParseUint(chownParts[1], 10, 32)
|
|
if err != nil {
|
|
return 1, fmt.Errorf("error %q as a numeric GID: %v", chownParts[1], err)
|
|
}
|
|
chownOpts = &idtools.IDPair{UID: int(uid), GID: int(gid)}
|
|
}
|
|
target := args[len(args)-1]
|
|
if strings.Contains(target, ":") {
|
|
targetParts := strings.SplitN(target, ":", 2)
|
|
if len(targetParts) != 2 {
|
|
return 1, fmt.Errorf("error parsing target location %q: only one part", target)
|
|
}
|
|
targetLayer, err := m.Layer(targetParts[0])
|
|
if err != nil {
|
|
return 1, fmt.Errorf("error finding layer %q: %+v", targetParts[0], err)
|
|
}
|
|
untarIDMappings = idtools.NewIDMappingsFromMaps(targetLayer.UIDMap, targetLayer.GIDMap)
|
|
targetMount, err := m.Mount(targetLayer.ID, targetLayer.MountLabel)
|
|
if err != nil {
|
|
return 1, fmt.Errorf("error mounting layer %q: %+v", targetLayer.ID, err)
|
|
}
|
|
target = filepath.Join(targetMount, targetParts[1])
|
|
defer func() {
|
|
if _, err := m.Unmount(targetLayer.ID, false); err != nil {
|
|
fmt.Fprintf(os.Stderr, "error unmounting layer %q: %+v\n", targetLayer.ID, err)
|
|
// Does not change the exit code
|
|
}
|
|
}()
|
|
}
|
|
args = args[:len(args)-1]
|
|
for _, srcSpec := range args {
|
|
var tarIDMappings *idtools.IDMappings
|
|
source := srcSpec
|
|
if strings.Contains(source, ":") {
|
|
sourceParts := strings.SplitN(source, ":", 2)
|
|
if len(sourceParts) != 2 {
|
|
return 1, fmt.Errorf("error parsing source location %q: only one part", source)
|
|
}
|
|
sourceLayer, err := m.Layer(sourceParts[0])
|
|
if err != nil {
|
|
return 1, fmt.Errorf("error finding layer %q: %+v", sourceParts[0], err)
|
|
}
|
|
tarIDMappings = idtools.NewIDMappingsFromMaps(sourceLayer.UIDMap, sourceLayer.GIDMap)
|
|
sourceMount, err := m.Mount(sourceLayer.ID, sourceLayer.MountLabel)
|
|
if err != nil {
|
|
return 1, fmt.Errorf("error mounting layer %q: %+v", sourceLayer.ID, err)
|
|
}
|
|
source = filepath.Join(sourceMount, sourceParts[1])
|
|
defer func() {
|
|
if _, err := m.Unmount(sourceLayer.ID, false); err != nil {
|
|
fmt.Fprintf(os.Stderr, "error unmounting layer %q: %+v\n", sourceLayer.ID, err)
|
|
// Does not change the exit code
|
|
}
|
|
}()
|
|
}
|
|
archiver := chrootarchive.NewArchiverWithChown(tarIDMappings, chownOpts, untarIDMappings)
|
|
if err := archiver.CopyWithTar(source, target); err != nil {
|
|
return 1, fmt.Errorf("error copying %q to %q: %+v", source, target, err)
|
|
}
|
|
}
|
|
return 0, nil
|
|
}
|
|
|
|
func init() {
|
|
commands = append(commands, command{
|
|
names: []string{"copy"},
|
|
usage: "Copy files or directories into a layer, possibly from another layer",
|
|
optionsHelp: "[options [...]] [sourceLayerNameOrID:]/path [...] targetLayerNameOrID:/path",
|
|
minArgs: 2,
|
|
maxArgs: -1,
|
|
action: copyContent,
|
|
addFlags: func(flags *mflag.FlagSet, cmd *command) {
|
|
flags.StringVar(&chownOptions, []string{"-chown", "o"}, chownOptions, "Set owner on new copies")
|
|
flags.BoolVar(&jsonOutput, []string{"-json", "j"}, jsonOutput, "Prefer JSON output")
|
|
},
|
|
})
|
|
}
|