Go: "tail -f" generatore -come

Question

ho avuto questa comoda funzione in Python:

def follow(path): 
    with open(self.path) as lines: 
     lines.seek(0, 2) # seek to EOF 

     while True: 
      line = lines.readline() 
      if not line: 
       time.sleep(0.1) 
        continue 
       yield line 

Si fa qualcosa di simile a UNIX tail -f: si ottiene ultime righe di un file come vengono. È conveniente perché è possibile ottenere il generatore senza bloccare e passarlo a un'altra funzione.

Poi ho dovuto fare la stessa cosa in Go. Sono nuovo in questa lingua, quindi non sono sicuro se quello che ho fatto sia idiomatico/corretto abbastanza per Go.

Ecco il codice:

func Follow(fileName string) chan string { 

    out_chan := make(chan string) 

    file, err := os.Open(fileName) 
    if err != nil { 
     log.Fatal(err) 
    } 

    file.Seek(0, os.SEEK_END) 
    bf := bufio.NewReader(file) 

    go func() { 
     for { 
      line, _, _ := bf.ReadLine() 

      if len(line) == 0 { 
       time.Sleep(10 * time.Millisecond) 
      } else { 
       out_chan <- string(line) 
      } 
     } 

     defer file.Close() 
     close(out_chan) 
    }() 

    return out_chan 
} 

Esiste un modo più pulito per fare questo in Go? Ho la sensazione che usare una chiamata asincrona per una cosa del genere sia eccessivo, e mi infastidisce davvero.

Answer 1

Suggerisco di creare un involucro attorno a un lettore che dorme su EOF:

type tailReader struct { 
    io.ReadCloser 
} 

func (t tailReader) Read(b []byte) (int, error) { 
    for { 
     n, err := t.ReadCloser.Read(b) 
     if n > 0 
      return n, nil 
     } else if err != io.EOF { 
      return n, err 
     } 
     time.Sleep(10 * time.Millisecond) 
    } 
} 

func newTailReader(fileName string) (tailReader, error) { 
    f, err := os.Open(fileName) 
    if err != nil { 
     return tailReader{}, err 
    } 

    if _, err := f.Seek(0, 2); err != nil { 
     return tailReader{}, err 
    } 
    return tailReader{f}, nil 
} 

Questo lettore può essere utilizzato ovunque un io.Reader può essere utilizzato. Ecco come un ciclo su linee con bufio.Scanner:

t, err := newTailReader("somefile") 
if err != nil { 
    log.Fatal(err) 
} 
defer t.Close() 
scanner := bufio.NewScanner(t) 
for scanner.Scan() { 
    fmt.Println(scanner.Text()) 
} 
if err := scanner.Err(); err != nil { 
    fmt.Fprintln(os.Stderr, "reading:", err) 
} 

Il lettore può essere utilizzato anche per un ciclo su valori JSON allegati al file:

t, err := newTailReader("somefile") 
if err != nil { 
    log.Fatal(err) 
} 
defer t.Close() 
dec := json.NewDecoder(t) 
for { 
    var v SomeType 
    if err := dec.Decode(&v); err != nil { 
     log.Fatal(err) 
    } 
    fmt.Println("the value is ", v) 
} 

Ci sono un paio di vantaggi di questo approccio ha il goroutine approccio delineato nella domanda. Il primo è che l'arresto è facile. Chiudi il file. Non è necessario segnalare alla goroutine che dovrebbe uscire. Il secondo vantaggio è che molti pacchetti funzionano con io.Reader.