Newsgroup: it.comp.os.linux.development
Titolo: leggere in tempo reale file di output che evolvono

salve a tutti, avrei un problema da risolvere:
il mio programma1 che ha un GUI, lancia in background (con una system)
il progra
mma2, quest'ultimo direziona l-output verso un file2.
vorrei che dall'interfaccia grafica del programma1 (scritta in GTK e
ovviamente
in C come tutti e due i programmi) si potesse vedere in tempo reale
l'evolvere d
el file2 di output, (mentre cioe' il programmma2 lo sta ancora
scrivendo)
come posso ottenere cio'? (e non dopo che il file e' stato scritto
tutto, questo mi e' molto semplice)
grazie della cortese attenzione

Magari ci sono modi + eleganti,
posizione=0;
while(1)
{
apri file
vai a "posizione"
stampa da "posizione" a "fine file"
posizione=fine_file
aspeta mezzo secondo
}
oppure potresti aprire con una pipe "tail -f <nome file>" (man popen)
G


con quale funzione faccio aspettare al SO mezzo secondo?
grazie del consiglio.
ciao

 tutto, questo mi e' molto semplice)
senza bisogno di gestire i files, il comando tail gia' fa questo: basta 
che lo usi come filtro verso un GtkText
/* codice di esempio non testato */
  FILE * output_di_tail;
  char buffer[4096];
  GtkWidget* text; /* lo suppongo gia' inizializzato */
  int pos, int len;
  output_di_tail = popen("tail -f --retry -s 1 miofile.log", "r");
  /* controlla ad intervallo di un secondo il file miofile.log, e
     continua a provare anche se il file e' inaccessibile */
  /* questo lo metterei in una f. aggiorna(), a cui passo il FILE* 
     che richiamo o in base ad una sleep(1), oppure a domanda diretta
  */
  pos = 0;
  while (len = fread((void*)buffer, 4096, 1, output_di_tail)) {
    gtk_editable_insert_text(GTK_EDITABLE(text), buff, len, &pos);
  }
 
  /* quando non ti serve piu' */ 
  pclose(output_di_tail);
-- 
Se l'appetito vien mangiando,
Figuriamoci a digiuno...
BW2K+2


OK! grazie,
ma come faccio a sapere quando non mi serve più?  cioè, mi spiego meglio, il
programma principale scritto in gtk lancia in background questo altro
programmino che produce il file che devo leggere, ma come faccio a far
capire al programma principale che l'altro programmino è finito e quindi
può chiudere il tail?
ciao e grazie

 finito e quindi puň chiudere il tail?
lo lanci con una system in un thread separato. quando il programma 
termina, system ritorna e puoi notificarlo, o con un segnale, o con una 
variabile, o come vuoi tu. sul mio sito c'e' una implementazione di 
messaggi interprocess in c++ 
web.tiscali.it/blakwolf/dev.html


 grazie del consiglio.
usleep
Ma io farei una cosa diversa:
Apri il file, setti le chiamate come blocking (man fcntl), quindi 
semplicemente leggi linea per linea. Alla fine del file, alla lettura, il 
processo andra' semplicemente in sleeping e verra' "svegliato" quando vi 
saranno altri dati disponibili. Ha un grosso vantaggio in termini di 
utilizzo del tempo macchina. Occhio che dovrai settare accuratamente il 
buffering del processo che "scrive" il file (man fnctl, ancora!)
-- 
HappyCactus - Registered Linux User #209744
http://utenti.tripod.it/happycactus
Made with 100% recycled electrons

 saranno altri dati disponibili. 
E' questo che fanno internamente le pipe?
All'originatore del thread: *forse* potresti indirizzare l'output del
primo programma ad una fifo e poi ascoltare su quella fifo.
Massimiliano

On Sat, 16 Mar 2002 19:17:50 +0000, 
mirc...@ineind.it
 
was talkin'about:

Potresti attaccare la lettura dal file (per es usando un GIOchannel) nel
mainloop del frontend con g_idle_add.
-- 
  Giuseppe "Cowo" Corbelli \/\ My software: 
http://cowo.yoda2000.net
    **ANTI-SPAM** -- **Substitute IHATESPAM with cowo to reply by mail**
  -<! Adding features does not necessarily increase functionality -- it just
		makes the manuals thicker. !>-

 E' questo che fanno internamente le pipe?
AFAIK, si. (piu' o meno)
