os.OpenFile avec O_RDONLY se bloque sur le canal nommé sans écrivain

PHP Editor Banana vous présente une méthode d'opération spéciale, qui consiste à utiliser la fonction os.OpenFile avec O_RDONLY pour monter sur un tube nommé sans écrivain. Cette méthode d'opération peut réaliser l'opération de lecture du canal nommé, vous permettant d'obtenir facilement les informations de données dans le canal nommé sans utiliser d'écrivain. Cette technique est simple à comprendre et à utiliser, ce qui en fait un excellent choix pour les développeurs lorsqu'il s'agit de canaux nommés. Ensuite, nous vous présenterons en détail comment utiliser cette méthode pour implémenter l'opération de lecture du canal nommé.

Contenu de la question

J'écris un démon qui devrait recevoir des notifications de commandes cli ad hoc et choisir de le faire via des canaux nommés Unix. J'ai écrit un court package qui, d'une part, génère une goroutine distincte pour lire à partir des nœuds et envoyer les notifications reçues aux canaux (aire de jeux avec tests unitaires) :

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
}

Cela semble fonctionner, mais il souffre d'un comportement particulier où aucun lecteur ne peut ouvrir le fichier avant qu'un écrivain n'ouvre le fichier, ce qui semble être le cas d'après d'autres articles que j'ai lus sur le contenu du sujet. pour inverser le comportement ; la plainte habituelle est que l'écrivain se bloque parce qu'il n'y a pas de lecteurs, cependant, ici, le lecteur ne peut pas être instancié en premier lieu.

Solution

Voici l'interface du système posix :

o_nonblock Lors de l'ouverture d'un fifo avec o_rdonly ou o_wronly défini : if o_nonblock est défini, open() en lecture seule reviendra sans Retard. S'il n'y a pas de processus, open() en écriture seule renverra une erreur Le fichier est actuellement ouvert en lecture.

Si o_nonblock est effacé, open() en lecture seule bloquera Appelé jusqu'à ce que le thread ouvre le fichier en écriture. un ouvert() L'écriture seule doit bloquer le thread appelant jusqu'à ce que le thread soit ouvert Fichier à lire.

Lors de l'ouverture de fichiers spéciaux de bloc ou de caractères spéciaux pris en charge Ouverture non bloquante :

Si o_nonblock est défini, la fonction open() reviendra sans Empêcher l'appareil d'être prêt ou disponible. comportement ultérieur Les propriétés du périphérique sont spécifiques au périphérique.

Si o_nonblock est effacé, la fonction open() bloquera l'appel l> Le fil ne revient que lorsque le périphérique est prêt ou disponible.

Sinon, le drapeau o_nonblock ne provoque pas d'erreur, mais c'est le cas. Il n'est pas précisé si l'indicateur d'état du fichier contient o_nonblock logo.

La solution est donc de mettre syscall.o_nonblock 标志添加到 openfile dans l'appel :

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

EDIT : Comme indiqué dans les commentaires, cette solution n'est pas portable pour darwin 环境。更便携的解决方案是在读取器端使用 o_rdwrouvrir des fichiers.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!