Le but est de faire un log-viewer (linux/Kdevelop).
Quel est a votre avis le meilleur moyen pour recuperer en temps-réel (ou
presque) les nouvelles lignes des fichiers concernés ?
Y'a-t-il une solution meilleure qu'ouvrir les fichiers toutes les x
secondes et recuperer les nouvelles entrées ?
Le but est de faire un log-viewer (linux/Kdevelop).
Quel est a votre avis le meilleur moyen pour recuperer en temps-réel (ou
presque) les nouvelles lignes des fichiers concernés ?
Y'a-t-il une solution meilleure qu'ouvrir les fichiers toutes les x
secondes et recuperer les nouvelles entrées ?
Le but est de faire un log-viewer (linux/Kdevelop).
Quel est a votre avis le meilleur moyen pour recuperer en temps-réel (ou
presque) les nouvelles lignes des fichiers concernés ?
Y'a-t-il une solution meilleure qu'ouvrir les fichiers toutes les x
secondes et recuperer les nouvelles entrées ?
Bonjour.
Le but est de faire un log-viewer (linux/Kdevelop).
Quel est a votre avis le meilleur moyen pour recuperer en temps-réel (ou
presque) les nouvelles lignes des fichiers concernés ?
Y'a-t-il une solution meilleure qu'ouvrir les fichiers toutes les x
secondes et recuperer les nouvelles entrées ?
Bonjour.
Le but est de faire un log-viewer (linux/Kdevelop).
Quel est a votre avis le meilleur moyen pour recuperer en temps-réel (ou
presque) les nouvelles lignes des fichiers concernés ?
Y'a-t-il une solution meilleure qu'ouvrir les fichiers toutes les x
secondes et recuperer les nouvelles entrées ?
Bonjour.
Le but est de faire un log-viewer (linux/Kdevelop).
Quel est a votre avis le meilleur moyen pour recuperer en temps-réel (ou
presque) les nouvelles lignes des fichiers concernés ?
Y'a-t-il une solution meilleure qu'ouvrir les fichiers toutes les x
secondes et recuperer les nouvelles entrées ?
Bonjour.
Le but est de faire un log-viewer (linux/Kdevelop).
Quel est a votre avis le meilleur moyen pour recuperer en temps-réel (ou
presque) les nouvelles lignes des fichiers concernés ?
Y'a-t-il une solution meilleure qu'ouvrir les fichiers toutes les x
secondes et recuperer les nouvelles entrées ?
Merci d'avance.
Bonjour.
Le but est de faire un log-viewer (linux/Kdevelop).
Quel est a votre avis le meilleur moyen pour recuperer en temps-réel (ou
presque) les nouvelles lignes des fichiers concernés ?
Y'a-t-il une solution meilleure qu'ouvrir les fichiers toutes les x
secondes et recuperer les nouvelles entrées ?
Merci d'avance.
Bonjour.
Le but est de faire un log-viewer (linux/Kdevelop).
Quel est a votre avis le meilleur moyen pour recuperer en temps-réel (ou
presque) les nouvelles lignes des fichiers concernés ?
Y'a-t-il une solution meilleure qu'ouvrir les fichiers toutes les x
secondes et recuperer les nouvelles entrées ?
Merci d'avance.
Grobill wrote:Le but est de faire un log-viewer (linux/Kdevelop). Quel est a
votre avis le meilleur moyen pour recuperer en temps-réel (ou
presque) les nouvelles lignes des fichiers concernés ? Y'a-t-il une
solution meilleure qu'ouvrir les fichiers toutes les x secondes et
recuperer les nouvelles entrées ?
Sur certain système, il est possible d'être notifié quand un fichier
change. C'est peut-être possible sous linux. Il faudrait demander dans
un groupe idoine.
Grobill wrote:
Le but est de faire un log-viewer (linux/Kdevelop). Quel est a
votre avis le meilleur moyen pour recuperer en temps-réel (ou
presque) les nouvelles lignes des fichiers concernés ? Y'a-t-il une
solution meilleure qu'ouvrir les fichiers toutes les x secondes et
recuperer les nouvelles entrées ?
Sur certain système, il est possible d'être notifié quand un fichier
change. C'est peut-être possible sous linux. Il faudrait demander dans
un groupe idoine.
Grobill wrote:Le but est de faire un log-viewer (linux/Kdevelop). Quel est a
votre avis le meilleur moyen pour recuperer en temps-réel (ou
presque) les nouvelles lignes des fichiers concernés ? Y'a-t-il une
solution meilleure qu'ouvrir les fichiers toutes les x secondes et
recuperer les nouvelles entrées ?
Sur certain système, il est possible d'être notifié quand un fichier
change. C'est peut-être possible sous linux. Il faudrait demander dans
un groupe idoine.
Arnaud Meurgues wrote in message
news:<40726277$0$14545$...Grobill wrote:Le but est de faire un log-viewer (linux/Kdevelop). Quel est a
votre avis le meilleur moyen pour recuperer en temps-réel (ou
presque) les nouvelles lignes des fichiers concernés ? Y'a-t-il une
solution meilleure qu'ouvrir les fichiers toutes les x secondes et
recuperer les nouvelles entrées ?
Sur certain système, il est possible d'être notifié quand un fichier
change. C'est peut-être possible sous linux. Il faudrait demander dans
un groupe idoine.
Ça dépend en effet du système. Autant que je sache, il n'y a pas de
telle fonctionnalité sous Linux. En général, on garde le fichier ouvert,
et on ressaie d'y lire de temps en temps.
Arnaud Meurgues <arnaud@meurgues.non.fr.invalid> wrote in message
news:<40726277$0$14545$626a14ce@news.free.fr>...
Grobill wrote:
Le but est de faire un log-viewer (linux/Kdevelop). Quel est a
votre avis le meilleur moyen pour recuperer en temps-réel (ou
presque) les nouvelles lignes des fichiers concernés ? Y'a-t-il une
solution meilleure qu'ouvrir les fichiers toutes les x secondes et
recuperer les nouvelles entrées ?
Sur certain système, il est possible d'être notifié quand un fichier
change. C'est peut-être possible sous linux. Il faudrait demander dans
un groupe idoine.
Ça dépend en effet du système. Autant que je sache, il n'y a pas de
telle fonctionnalité sous Linux. En général, on garde le fichier ouvert,
et on ressaie d'y lire de temps en temps.
Arnaud Meurgues wrote in message
news:<40726277$0$14545$...Grobill wrote:Le but est de faire un log-viewer (linux/Kdevelop). Quel est a
votre avis le meilleur moyen pour recuperer en temps-réel (ou
presque) les nouvelles lignes des fichiers concernés ? Y'a-t-il une
solution meilleure qu'ouvrir les fichiers toutes les x secondes et
recuperer les nouvelles entrées ?
Sur certain système, il est possible d'être notifié quand un fichier
change. C'est peut-être possible sous linux. Il faudrait demander dans
un groupe idoine.
Ça dépend en effet du système. Autant que je sache, il n'y a pas de
telle fonctionnalité sous Linux. En général, on garde le fichier ouvert,
et on ressaie d'y lire de temps en temps.
Pour ceux que ca pourrait interesser j'ai trouvé une solution en
regardant mieux la STL. ios fournit la classe filebuf qui permet
d'avoir un buffer en lecture (et ecriture aussi) d'un fichier
ouvert. De cette maniere la lecture est continue et transparente et on
ne check que le nombre de char available dans le buffer qd on le
desire.
Pour ceux que ca pourrait interesser j'ai trouvé une solution en
regardant mieux la STL. ios fournit la classe filebuf qui permet
d'avoir un buffer en lecture (et ecriture aussi) d'un fichier
ouvert. De cette maniere la lecture est continue et transparente et on
ne check que le nombre de char available dans le buffer qd on le
desire.
Pour ceux que ca pourrait interesser j'ai trouvé une solution en
regardant mieux la STL. ios fournit la classe filebuf qui permet
d'avoir un buffer en lecture (et ecriture aussi) d'un fichier
ouvert. De cette maniere la lecture est continue et transparente et on
ne check que le nombre de char available dans le buffer qd on le
desire.
Grobill wrote in message
news:...Pour ceux que ca pourrait interesser j'ai trouvé une solution en
regardant mieux la STL. ios fournit la classe filebuf qui permet
d'avoir un buffer en lecture (et ecriture aussi) d'un fichier
ouvert. De cette maniere la lecture est continue et transparente et on
ne check que le nombre de char available dans le buffer qd on le
desire.
Et comment fait-on pour voir s'il y a des caractères disponibles ? Je
crois que la sémantique garantie de in_avail() va te decevoir, si c'est
sur elle que tu comptais. (Mais il se peut que ton implémentation en
garantisse plus. Je ne sais rien en ce qui concerne g++ ici.)
--
James Kanze GABI Software mailto:
Conseils en informatique orientée objet/ http://www.gabi-soft.fr
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Grobill <grobillz@free.fr> wrote in message
news:<Xns94C5527F246EDyvlauradourwanadoofr@193.252.19.141>...
Pour ceux que ca pourrait interesser j'ai trouvé une solution en
regardant mieux la STL. ios fournit la classe filebuf qui permet
d'avoir un buffer en lecture (et ecriture aussi) d'un fichier
ouvert. De cette maniere la lecture est continue et transparente et on
ne check que le nombre de char available dans le buffer qd on le
desire.
Et comment fait-on pour voir s'il y a des caractères disponibles ? Je
crois que la sémantique garantie de in_avail() va te decevoir, si c'est
sur elle que tu comptais. (Mais il se peut que ton implémentation en
garantisse plus. Je ne sais rien en ce qui concerne g++ ici.)
--
James Kanze GABI Software mailto:kanze@gabi-soft.fr
Conseils en informatique orientée objet/ http://www.gabi-soft.fr
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Grobill wrote in message
news:...Pour ceux que ca pourrait interesser j'ai trouvé une solution en
regardant mieux la STL. ios fournit la classe filebuf qui permet
d'avoir un buffer en lecture (et ecriture aussi) d'un fichier
ouvert. De cette maniere la lecture est continue et transparente et on
ne check que le nombre de char available dans le buffer qd on le
desire.
Et comment fait-on pour voir s'il y a des caractères disponibles ? Je
crois que la sémantique garantie de in_avail() va te decevoir, si c'est
sur elle que tu comptais. (Mais il se peut que ton implémentation en
garantisse plus. Je ne sais rien en ce qui concerne g++ ici.)
--
James Kanze GABI Software mailto:
Conseils en informatique orientée objet/ http://www.gabi-soft.fr
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Quel devrait etre le probleme ?
J'ai testé avec in_avail en effet, mais ca a l'air de fonctionner...
J'ai juste ecrit un petit test a la va-vite pour verifier justement :
using namespace std;
int main(int argc, char *argv[]) {
int n = 0;
int nblus = 0;
ios::pos_type lastpos;
std::streamsize nbavail, nbgot;
ifstream pipofile;
char cline[4096];
filebuf *pipobuf;
pipobuf = pipofile.rdbuf();
pipobuf->open("/var/log/messages", ios::in | ios::ate);
while(n==0) {
nbavail = pipobuf->in_avail();
cout << nbavail << endl;
if(nbavail > 30) {
nbgot = pipobuf->sgetn(cline, nbavail);
cline[nbgot-2] = ' ';
cout << cline << endl;
}
sleep(2);
}
pipobuf->close();
return EXIT_SUCCESS;
}
Quel devrait etre le probleme ?
J'ai testé avec in_avail en effet, mais ca a l'air de fonctionner...
J'ai juste ecrit un petit test a la va-vite pour verifier justement :
using namespace std;
int main(int argc, char *argv[]) {
int n = 0;
int nblus = 0;
ios::pos_type lastpos;
std::streamsize nbavail, nbgot;
ifstream pipofile;
char cline[4096];
filebuf *pipobuf;
pipobuf = pipofile.rdbuf();
pipobuf->open("/var/log/messages", ios::in | ios::ate);
while(n==0) {
nbavail = pipobuf->in_avail();
cout << nbavail << endl;
if(nbavail > 30) {
nbgot = pipobuf->sgetn(cline, nbavail);
cline[nbgot-2] = ' ';
cout << cline << endl;
}
sleep(2);
}
pipobuf->close();
return EXIT_SUCCESS;
}
Quel devrait etre le probleme ?
J'ai testé avec in_avail en effet, mais ca a l'air de fonctionner...
J'ai juste ecrit un petit test a la va-vite pour verifier justement :
using namespace std;
int main(int argc, char *argv[]) {
int n = 0;
int nblus = 0;
ios::pos_type lastpos;
std::streamsize nbavail, nbgot;
ifstream pipofile;
char cline[4096];
filebuf *pipobuf;
pipobuf = pipofile.rdbuf();
pipobuf->open("/var/log/messages", ios::in | ios::ate);
while(n==0) {
nbavail = pipobuf->in_avail();
cout << nbavail << endl;
if(nbavail > 30) {
nbgot = pipobuf->sgetn(cline, nbavail);
cline[nbgot-2] = ' ';
cout << cline << endl;
}
sleep(2);
}
pipobuf->close();
return EXIT_SUCCESS;
}
writes:Arnaud Meurgues wrote in message
news:<40726277$0$14545$...Grobill wrote:Le but est de faire un log-viewer (linux/Kdevelop). Quel est a
votre avis le meilleur moyen pour recuperer en temps-réel (ou
presque) les nouvelles lignes des fichiers concernés ? Y'a-t-il
une solution meilleure qu'ouvrir les fichiers toutes les x
secondes et recuperer les nouvelles entrées ?
Sur certain système, il est possible d'être notifié quand un
fichier change. C'est peut-être possible sous linux. Il faudrait
demander dans un groupe idoine.
Ça dépend en effet du système. Autant que je sache, il n'y a pas de
telle fonctionnalité sous Linux. En général, on garde le fichier
ouvert, et on ressaie d'y lire de temps en temps.
Je crois que c'est ce que fait "tail -f", il faudrait aller voir les
sources de tail, qui ne doivent pas être trop compliquées ...
kanze@gabi-soft.fr writes:
Arnaud Meurgues <arnaud@meurgues.non.fr.invalid> wrote in message
news:<40726277$0$14545$626a14ce@news.free.fr>...
Grobill wrote:
Le but est de faire un log-viewer (linux/Kdevelop). Quel est a
votre avis le meilleur moyen pour recuperer en temps-réel (ou
presque) les nouvelles lignes des fichiers concernés ? Y'a-t-il
une solution meilleure qu'ouvrir les fichiers toutes les x
secondes et recuperer les nouvelles entrées ?
Sur certain système, il est possible d'être notifié quand un
fichier change. C'est peut-être possible sous linux. Il faudrait
demander dans un groupe idoine.
Ça dépend en effet du système. Autant que je sache, il n'y a pas de
telle fonctionnalité sous Linux. En général, on garde le fichier
ouvert, et on ressaie d'y lire de temps en temps.
Je crois que c'est ce que fait "tail -f", il faudrait aller voir les
sources de tail, qui ne doivent pas être trop compliquées ...
writes:Arnaud Meurgues wrote in message
news:<40726277$0$14545$...Grobill wrote:Le but est de faire un log-viewer (linux/Kdevelop). Quel est a
votre avis le meilleur moyen pour recuperer en temps-réel (ou
presque) les nouvelles lignes des fichiers concernés ? Y'a-t-il
une solution meilleure qu'ouvrir les fichiers toutes les x
secondes et recuperer les nouvelles entrées ?
Sur certain système, il est possible d'être notifié quand un
fichier change. C'est peut-être possible sous linux. Il faudrait
demander dans un groupe idoine.
Ça dépend en effet du système. Autant que je sache, il n'y a pas de
telle fonctionnalité sous Linux. En général, on garde le fichier
ouvert, et on ressaie d'y lire de temps en temps.
Je crois que c'est ce que fait "tail -f", il faudrait aller voir les
sources de tail, qui ne doivent pas être trop compliquées ...