Moyen Simple de copier un fichier dans Golang

Une copierobuste etefficace est conceptuellement simple, mais pas simple à implémenter en raison de la nécessité de gérer un certain nombre de cas périphériques et de limitations système imposées par le système d'exploitation cible et sa configuration.

Si vous voulez simplement faire une copie du fichier existant, vous pouvez utiliser os.Link(srcName, dstName). Cela évite d'avoir à déplacer d'octets dans l'application et économise de l'espace disque. Pour les fichiers volumineux, c'est un temps et un espace importants économie.

Mais différents systèmes d'exploitation ont des restrictions différentes sur la façon dont les liens durs fonctionnent. Selon votre application et la configuration de votre système cible, les appels Link() peuvent ne pas fonctionner dans tous les cas.

Si vous voulez une seule fonction de copie Générique, robuste et efficace, mettez à jour Copy() vers:

1. effectuer des vérifications pour s'assurer qu'au moins une forme de copie réussira (autorisations d'accès, répertoires existent, etc.)
2. vérifiez si les deux fichiers existent déjà et sont les mêmes en utilisant os.SameFile, Retour succès si elles sont les mêmes
3. tentative D'un lien, retour en cas de succès
4. Copiez les octets (tous les moyens efficaces ont échoué), renvoyez le résultat

Une optimisation consisterait à copier les octets dans une routine go afin que l'appelant ne bloque pas la copie d'octets. Cela impose une complexité supplémentaire à l'appelant pour gérer correctement le cas de réussite / erreur.

Si je voulais les deux, j'aurais deux fonctions de copie différentes: CopyFile(src, dst string) (error) pour une copie bloquante et {[6] } qui transmet un canal de signalisation à l'appelant pour le cas asynchrone.

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")
    }
}