Wie kann verhindert werden, dass Programm B Dateien archiviert/löscht, die derzeit von Programm A in Go geöffnet sind?

Go-Sprache ist eine leistungsstarke Programmiersprache, bei der Verarbeitung von Dateioperationen können jedoch einige Probleme auftreten. Insbesondere wenn Programm A eine Datei öffnet, versucht Programm B möglicherweise, die Datei zu archivieren oder zu löschen, was zu einem Fehler bei Programm A führen kann. Der PHP-Editor Xigua stellt hier einige Methoden vor, mit denen Sie verhindern können, dass Programm B die aktuell von Programm A in der Go-Sprache geöffnete Datei ausführt, um den stabilen Betrieb des Programms sicherzustellen. Hier sind einige Lösungen:

Frageninhalt

Programmiersprache: Verwenden Sie die neueste Version

Ich arbeite an einem Programm A, das Protokolldateien in einem Verzeichnis archivieren muss, mit Ausnahme der Protokolldateien, die von Programm B geöffnet wurden, das es zur Protokollierung verwendet. Geöffnete Dateien werden nach einer bestimmten Dauer (z. B. 24 Stunden) geschlossen und stehen dann zur Archivierung zur Verfügung. Offensichtlich laufen beide Programme unabhängig voneinander.

Die aktuelle Implementierung prüft nicht, ob die Datei in Programm B geöffnet ist, und da ich kürzlich festgestellt habe, dass offene Protokolldateien archiviert werden, glaube ich nicht, dass dies im Grunde genommen der Fall ist, sondern die Datei in das Archiv kopiert und gelöscht wird .

Was ist eine zuverlässige Methode, um zu überprüfen, ob eine Datei derzeit von einem anderen Go-Programm geöffnet ist, bevor versucht wird, sie zu archivieren?

Ich habe den Archivierer geschrieben, aber ich werde ihn hier nicht veröffentlichen, da es keinen Code gibt, der für die Frage nicht relevant ist. Daher werde ich nur den Code hinzufügen, der die Archivierung und Löschung durchführt.

Ich habe erfolglos versucht, die Funktionen Open und OpenFile zu verwenden.

func zipFile(filename string) error {
    file, err := os.Open(filename)

    if err != nil {
        return err
    }

    defer func(file *os.File) {
        err = file.Close()

        if err != nil {
            fmt.Println(err)
        }
    }(file)

    fileInfo, err := file.Stat()

    if err != nil {
        return err
    }

    archiveFile, err := os.Create(fmt.Sprintf("%s.zip", filename))

    if err != nil {
        return err
    }

    defer func(archiveFile *os.File) {
        err = archiveFile.Close()

        if err != nil {
            fmt.Println(err)
        }
    }(archiveFile)

    zipWriter := zip.NewWriter(archiveFile)

    if err != nil {
        return err
    }

    defer func(zipWriter *zip.Writer) {
        err = zipWriter.Close()

        if err != nil {
            fmt.Println(err)
        }
    }(zipWriter)

    writer, err := zipWriter.Create(fileInfo.Name())

    if err != nil {
        return err
    }

    _, err = io.Copy(writer, file)

    if err != nil {
        return err
    }

    err = os.Remove(filename)

    if err != nil {
        return err
    }

    fmt.Println(fmt.Sprintf("file %s was zipped", fileInfo.Name()))

    return nil
}

Workaround

Unabhängig vom Prozess hängt das Problem, zu wissen, ob eine Datei von einem anderen Prozess geöffnet ist, stark vom zugrunde liegenden Betriebssystem ab. Daher gibt es keine universelle plattformübergreifende Möglichkeit, diese Frage zu beantworten. Bei *NIX-Systemen (Unix, Linux, macOS) lässt sich Ihre Frage am besten mit dem Core-Util lsof („offene Dateien auflisten“) beantworten.

Auf macOS sieht es so aus:

package main

import (
    "fmt"
    "os/exec"
    "strings"
)

func main() {
    out, _ := exec.Command("lsof").Output()
    for _, line := range strings.Split(string(out), "\n") {
        // Skip anything that's not a regular file
        if !strings.Contains(line, "REG") { 
            continue
        }

        fields := strings.Fields(line)

        // The macOS lsof command has the filename in the ninth field
        fmt.Println(fields[8])
    }
}

Alternativ können Sie eine Bibliothek finden, die dies abstrahiert, wie zum Beispiel: https://github.com/wheel-complex/lsof

Weitere Informationen zu lsof: //m.sbmmt.com/link/fa2246fa0fdf0d3e270c86767b77ba1b

Das obige ist der detaillierte Inhalt vonWie kann verhindert werden, dass Programm B Dateien archiviert/löscht, die derzeit von Programm A in Go geöffnet sind?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!