otiai10/copy Go Library

The copy package provides a simple way to copy directories recursively. Use cp.Copy(src, dest) to perform a standard recursive copy from a source path to a destination path.

package main

import (
	"fmt"
	cp "github.com/otiai10/copy"
)

func main() {
	err := cp.Copy("your/src", "your/dest")
	fmt.Println(err) // nil
}

The AddPermission function is a helper that generates a PermissionControlFunc. It allows you to bitwise OR additional permissions onto the original source permissions.

When using AddPermission(perm):

• If the source is a directory, it first creates the destination directory using 0755 permissions (tmpPermissionForDirectory) to ensure the copy process can continue even if the source directory is read-only.
• The returned chmodfunc will attempt to apply the original mode combined with the provided perm bits to the destination.

AddPermission = func(perm os.FileMode) PermissionControlFunc {

The OnError field in Options allows you to decide whether the copy operation should continue or stop when an error occurs. The callback receives the source path, destination path, and the error encountered. To continue, return nil. To stop the operation, return the error.

opt := copy.Options{
    OnError: func(src, dest string, err error) error {
        if isRecoverable(err) {
            return nil // Continue
        }
        return err // Stop
    },
}

The RenameDestination field in Options allows you to modify the destination path for a specific file or directory before the copy occurs. The callback receives the source and destination paths and must return the new destination path string.

opt := copy.Options{
    RenameDestination: func(src, dest string) (string, error) {
        return dest + ".bak", nil
    },
}

You can control how the library performs concurrent copying of directory contents:

• NumOfWorkers: The number of workers used for concurrent copying. If set to 0 or 1, concurrency is disabled for directory contents.
• PreferConcurrent: A callback function func(srcdir, destdir string) (bool, error) that allows you to decide on a per-directory basis whether to use goroutines for copying. If nil (default), it uses concurrent copying for all directories (provided NumOfWorkers > 1).

opt := copy.Options{
    NumOfWorkers: 4,
    PreferConcurrent: func(srcdir, destdir string) (bool, error) {
        // Only use concurrency for specific paths
        if strings.Contains(srcdir, "large_data") {
            return true, nil
        }
        return false, nil
    },
}

The Skip field in Options allows you to exclude specific files from the copy operation based on their metadata or paths. The callback receives the os.FileInfo, the source path, and the destination path. Return true to skip the file, or false to include it.

opt := copy.Options{
    Skip: func(srcinfo os.FileInfo, src, dest string) (bool, error) {
        if srcinfo.IsDir() && src == "/some/ignored/dir" {
            return true, nil
        }
        return false, nil
    },
}

The OnDirExists field in Options allows you to define a callback function that determines what happens when a directory already exists at the destination path. The callback receives the source and destination paths and must return a DirExistsAction.

Available DirExistsAction values:

• Merge: Preserves or overwrites existing files under the directory (default behavior).
• Replace: Deletes all contents under the destination directory and copies the source files.
• Untouchable: Does nothing; the existing directory is left as is.

opt := copy.Options{
    OnDirExists: func(src, dest string) copy.DirExistsAction {
        return copy.Replace
    },
}

The PermissionControlFunc type allows you to define custom logic for how file permissions (modes) are applied to destination files and directories during a copy operation.

It is a function that takes the source file information (fs.FileInfo) and the destination path (string) and returns:

1. A chmodfunc (a function that accepts a pointer to an error *error) used to apply the permission changes.
2. An error if the initial setup (like directory creation) fails.

This is useful if you need to intercept the permission application process or handle directory creation specifically.

type PermissionControlFunc func(srcinfo fs.FileInfo, dest string) (chmodfunc func(*error), err error)