Forma sencilla de copiar un archivo en Golang

Un robusto y eficiente copiar es conceptualmente simple, pero no fácil de implementar debido a la necesidad de manejar un número de casos de borde del sistema y de las limitaciones que son impuestas por el sistema operativo de destino y configuración.

Si simplemente desea hacer un duplicado del archivo existente, puede usar os.Link(srcName, dstName). Esto evita tener que mover bytes en la aplicación y ahorra espacio en disco. Para archivos grandes, este es un tiempo y espacio significativos ahorro.

Pero varios sistemas operativos tienen diferentes restricciones sobre cómo funcionan los enlaces duros. Dependiendo de su aplicación y la configuración de su sistema de destino, las llamadas Link() pueden no funcionar en todos los casos.

Si desea una única función de copia genérica, robusta y eficiente, actualice Copy() a:

1. Realice comprobaciones para asegurarse de que al menos alguna forma de copia tendrá éxito (permisos de acceso, existen directorios, etc.)
2. Compruebe si ambos archivos ya existen y son los mismos usando os.SameFile, devuelve el éxito si son los mismos
3. Intenta un enlace, devuelve si tiene éxito
4. Copie los bytes (todos los medios eficientes fallaron), devuelva el resultado

Una optimización sería copiar los bytes en una rutina go para que la persona que llama no bloquee la copia de bytes. Hacerlo impone complejidad adicional a la persona que llama para manejar el caso de éxito/error correctamente.

Si quisiera ambos, tendría dos funciones de copia diferentes: CopyFile(src, dst string) (error) para una copia de bloqueo y CopyFileAsync(src, dst string) (chan c, error) que pasa un canal de señalización de nuevo a la persona que llama para el caso asíncrono.

package main

import (
    "fmt"
    "io"
    "os"
)

// CopyFile copies a file from src to dst. If src and dst files exist, and are
// the same, then return success. Otherise, attempt to create a hard link
// between the two files. If that fail, copy the file contents from src to dst.
func CopyFile(src, dst string) (err error) {
    sfi, err := os.Stat(src)
    if err != nil {
        return
    }
    if !sfi.Mode().IsRegular() {
        // cannot copy non-regular files (e.g., directories,
        // symlinks, devices, etc.)
        return fmt.Errorf("CopyFile: non-regular source file %s (%q)", sfi.Name(), sfi.Mode().String())
    }
    dfi, err := os.Stat(dst)
    if err != nil {
        if !os.IsNotExist(err) {
            return
        }
    } else {
        if !(dfi.Mode().IsRegular()) {
            return fmt.Errorf("CopyFile: non-regular destination file %s (%q)", dfi.Name(), dfi.Mode().String())
        }
        if os.SameFile(sfi, dfi) {
            return
        }
    }
    if err = os.Link(src, dst); err == nil {
        return
    }
    err = copyFileContents(src, dst)
    return
}

// copyFileContents copies the contents of the file named src to the file named
// by dst. The file will be created if it does not already exist. If the
// destination file exists, all it's contents will be replaced by the contents
// of the source file.
func copyFileContents(src, dst string) (err error) {
    in, err := os.Open(src)
    if err != nil {
        return
    }
    defer in.Close()
    out, err := os.Create(dst)
    if err != nil {
        return
    }
    defer func() {
        cerr := out.Close()
        if err == nil {
            err = cerr
        }
    }()
    if _, err = io.Copy(out, in); err != nil {
        return
    }
    err = out.Sync()
    return
}

func main() {
    fmt.Printf("Copying %s to %s\n", os.Args[1], os.Args[2])
    err := CopyFile(os.Args[1], os.Args[2])
    if err != nil {
        fmt.Printf("CopyFile failed %q\n", err)
    } else {
        fmt.Printf("CopyFile succeeded\n")
    }
}