os.OpenFile mit O_RDONLY hängt an der Named Pipe ohne Writer

Der PHP-Editor Banana führt Sie in eine spezielle Operationsmethode ein, bei der die Funktion os.OpenFile mit O_RDONLY verwendet wird, um ohne Writer auf einer Named Pipe zu mounten. Diese Operationsmethode kann den Lesevorgang der Named Pipe realisieren, sodass Sie die Dateninformationen in der Named Pipe problemlos abrufen können, ohne einen Writer zu verwenden. Diese Technik ist einfach zu verstehen und einfach zu bedienen, was sie zu einer ausgezeichneten Wahl für Entwickler beim Umgang mit Named Pipes macht. Als Nächstes stellen wir Ihnen detailliert vor, wie Sie mit dieser Methode den Lesevorgang der Named Pipe implementieren.

Frageninhalt

Ich schreibe einen Daemon, der Benachrichtigungen von Ad-hoc-CLI-Befehlen empfangen soll und dies über Unix-Named Pipes tun soll. Ich habe ein kurzes Paket geschrieben, das einerseits eine separate Goroutine generiert, um von Knoten zu lesen und empfangene Benachrichtigungen an Kanäle zu senden (Spielwiese mit Unit-Tests):

type Writer struct {
    f *os.File
}

func NewWriter(ipc string) (*Writer, error) {
    f, err := os.OpenFile(ipc, os.O_WRONLY, 0600)

    if err != nil {
        return nil, fmt.Errorf("writer: open file: %w", err)
    }

    return &Writer{f: f}, nil
}

func (w *Writer) WriteString(str string) (int, error) {
    return w.f.WriteString(fmt.Sprint(str, "\n"))

}

func (w *Writer) Close() error {
    return w.f.Close()
}

type Reader struct {
    f    *os.File
    rmFn func() error
    quit chan struct{}
    done *sync.WaitGroup
}

func NewReader(ipc string) (*Reader, error) {
    err := syscall.Mkfifo(ipc, 0640)
    if err != nil {
        return nil, fmt.Errorf("reader: create fifo: %w", err)
    }

    f, err := os.OpenFile(ipc, os.O_RDONLY, 0640)
    if err != nil {
        return nil, fmt.Errorf("reader: open fifo: %w", err)
    }
    return &Reader{
        f:    f,
        quit: make(chan struct{}),
        done: &sync.WaitGroup{},
        rmFn: func() error {
            return os.Remove(ipc)
        },
    }, nil
}

func (r *Reader) PollRead() <-chan string {
    reader := bufio.NewReader(r.f)
    out := make(chan string)
    r.done.Add(1)
    go func() {
        defer r.done.Done()
        for {
            line, err := reader.ReadBytes('\n')
            if err != nil {
                fmt.Printf("error reading from named pipe: %v\n", err)
                return
            }

            nline := string(line)
            nline = strings.TrimRight(nline, "\n")
            select {
            case out <- nline:
            case <-r.quit:
                close(out)
                return
            }
        }
    }()

    return out
}

func (r *Reader) Close() error {
    close(r.quit)
    r.done.Wait()
    err := r.f.Close()
    if err != nil {
        return fmt.Errorf("error closing named pipe: %v", err)
    }

    err = r.rmFn()
    if err != nil {
        return fmt.Errorf("error removing named pipe: %v", err)
    }
    return nil
}

Das scheint zu funktionieren, aber es weist ein eigenartiges Verhalten auf, bei dem kein Leser die Datei öffnen kann, bevor irgendein Autor die Datei öffnet, was aufgrund anderer Beiträge, die ich zu diesem Thema gelesen habe, der Fall zu sein scheint um das Verhalten umzukehren; die übliche Beschwerde ist, dass der Autor hängen bleibt, weil es keine Leser gibt, hier kann der Leser jedoch überhaupt nicht instanziiert werden.

Lösung

Dies ist die posix-Systemschnittstelle:

o_nonblock Beim Öffnen eines FIFO mit o_rdonly oder o_wronly gesetzt: if o_nonblock ist gesetzt, schreibgeschütztes open() wird ohne zurückgegeben Verzögerung. Wenn kein Prozess vorhanden ist, gibt die schreibgeschützte Funktion open() einen Fehler zurück Die Datei ist derzeit zum Lesen geöffnet.

Wenn o_nonblock gelöscht ist, blockiert die schreibgeschützte Funktion open() Wird aufgerufen, bis der Thread die Datei zum Schreiben öffnet. ein offenes() Schreibgeschützt sollte den aufrufenden Thread blockieren, bis der Thread geöffnet wird Datei zum Nachlesen.

Beim Öffnen unterstützter Blockspezial- oder Zeichenspezialdateien Nicht blockierend geöffnet:

Wenn o_nonblock gesetzt ist, wird die Funktion open() ohne zurückgegeben Verhindern Sie, dass das Gerät bereit oder verfügbar ist. nachfolgendes Verhalten Geräteeigenschaften sind gerätespezifisch.

Wenn o_nonblock gelöscht ist, blockiert die Funktion open() den Aufruf l> Der Thread kehrt erst zurück, wenn das Gerät bereit oder verfügbar ist.

Andernfalls verursacht das Flag o_nonblock keinen Fehler, ist aber der Fall Es ist nicht angegeben, ob das Dateistatus-Flag o_nonblock enthält Logo.

Die Lösung besteht also darin, syscall.o_nonblock 标志添加到 openfile in den Anruf einzufügen:

f, err := os.OpenFile(ipc, os.O_RDONLY|syscall.O_NONBLOCK, 0640)

BEARBEITEN: Wie in den Kommentaren besprochen, ist diese Lösung nicht zum darwin 环境。更便携的解决方案是在读取器端使用 o_rdwrÖffnen von Dateien portierbar.

Das obige ist der detaillierte Inhalt vonos.OpenFile mit O_RDONLY hängt an der Named Pipe ohne Writer. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!