Discussion :

[Skarsnick]

Bonjour,
Je cherche aujourd'hui à faire un fichier de log.
Le but du jeu est que mes lib puissent renvoyer leurs messages d'erreurs vers un fichier et que mon appli principale affiche ce fichier dans une text area.

Voilà ce que j'ai fais:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
	GIOChannel *pFichierLog;
	GError *pErr = NULL;
	pFichierLog = g_io_channel_new_file("./IHM/test","r",&pErr);
	g_io_add_watch(pFichierLog,G_IO_IN,FonctionUpdateLog,NULL);

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
// LOG
gboolean FonctionUpdateLog(GIOChannel *gio,GIOCondition condition, gpointer data)
{
	gchar * msg;
	GError *pErr = NULL;
	gsize len;
	g_io_channel_read_line(gio, &msg, &len, NULL, &pErr);
	printf("log?");
}

Je voulais donc que la fonction FonctionUpdateLog ne soit appelée qu'en cas de changement sur le fichier /IHM/test mais là elle est appeler tout le temps même quand /IHM/test est vide!
J'ai mal compris la fonction je pense.
Vous connaissez une autre façon de faire?
Si je met un update de ma textArea à la place de mon printf("log?") ça rafraichira ma fenêtre mais ça va spammer comme pas possible, niveau performance ça craint...
Merci!

[liberforce]

A quel moment exactement est-ce que ta fonction de log est appelée au juste ? Et qu'est ce qu'elle lit ? Je te conseille d'améliorer tes traces en rajoutant dans ton printf les données qui ont été lues, pour voir ce qui se passe. Et si tu écris avec une autre application dans ce fichier à ce moment là, est-ce que le résultat dans ton appli est correct ?

[Skarsnick]

Bonjour!
Merci de ta réponse.
En faite quand je lance mon appli dans la console j'ai des log?log?log?log?log?log?log?log?log?log?log?log?log?
Donc ma fonction à l'air appelé tous le temps...
Elle lit le fichier de log qui est vide actuellement

Et l'application ne charge plus le reste de l'interface graphique.
Pour le moment rien ne modifie le fichier en question et il est vide au départ ^^

Une idée?

[liberforce]

Bon, alors tout d'abord, c'est plus facile d'avoir une idée quand on vérifie les codes de retour... Tu ne le fais pas et c'est une très mauvaise habitude.
Voici un exemple autonome qui reproduit le problème, avec des traces...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
gboolean
FonctionUpdateLog (GIOChannel *source,
                GIOCondition condition,
                gpointer data)
{
        gchar * msg;
        GError *pErr = NULL;
        gsize len;
        GIOStatus status;
 
        g_assert (condition == G_IO_IN);
        status = g_io_channel_read_line (source, &msg, &len, NULL, &pErr);
        switch (status)
        {
                case G_IO_STATUS_NORMAL:
                        g_debug ("Data read = '%s'", msg);
                        g_free (msg);
                        break;
 
                case G_IO_STATUS_ERROR:
                        g_assert (pErr != NULL);
                        g_error ("%s", pErr->message);
                        break;
 
                case G_IO_STATUS_EOF:
                        g_debug ("End of file detected");
                        break;
 
                case G_IO_STATUS_AGAIN:
                        g_debug ("Resource is busy, we'll try again");
                        break;
 
                default:
                        g_assert_not_reached ();
        }
 
        return TRUE;
}
 
 
int main (int argc,  char**argv)
{
        GMainLoop *loop;
        GIOChannel *pFichierLog;
        GError *pErr = NULL;
        pFichierLog = g_io_channel_new_file("./testfile","r",&pErr);
        g_io_add_watch (pFichierLog, G_IO_IN, FonctionUpdateLog, NULL);
        loop = g_main_loop_new (NULL, FALSE);
        g_main_loop_run (loop);
}

Au vu des traces, on dirait que l'IOChannel fait du polling sur le descripteur de fichiers, et ta callback est appelée sans cesse parce que la condition "données à lire" (G_IO_IN) est remplie. Même si ce n'est que pour te rendre compte que tu es à la fin du fichier (G_IO_STATUS_EOF)...

Donc ont dit sans cesse "y a des données à lire" et quand tu vas voir on te dit "ah bah non, t'es à la fin du fichier". J'aurais pensé comme toi avant de faire le test, que tu n'aurais été averti qu'en cas de réception de données réelles...

[Skarsnick]

Bonjour,
Un grand merci pour ta réponse,
j'ai un poil modifier ton code pour y glisser le mien (en mode un peu violent je le reconnais)

Voici le main

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
				/* Recuperation du buffer */
				gchar *sBuffer;
				GtkTextBuffer *pTextBuffer;
				GtkTextIter iStart, iEnd;
				g_file_get_contents("./IHM/test", &sBuffer, NULL, NULL);
				pTextBuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(TabPrinter->pTextViewLog));
				/* Suppression des données du buffer */
				gtk_text_buffer_get_start_iter(pTextBuffer, &iStart);
				gtk_text_buffer_get_end_iter(pTextBuffer, &iEnd);
				gtk_text_buffer_delete(pTextBuffer, &iStart, &iEnd);
				/* Affichage du fichier */
				gtk_text_buffer_get_start_iter(pTextBuffer, &iStart);
				gtk_text_buffer_insert(pTextBuffer, &iStart, sBuffer, -1);
				g_free(sBuffer);
 
[...]	
 
	GIOChannel *pFichierLog;
	GError *pErr = NULL;
	pFichierLog = g_io_channel_new_file("./IHM/test","r",&pErr);
        g_io_add_watch (pFichierLog, G_IO_IN, FonctionUpdateLog, (gpointer*) TabPrinter);
 
	if(pErr)
		g_print("Erreur = %s\n",pErr->message);
 
	gtk_main();

Et la fonction de log:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
 
// LOG
gboolean FonctionUpdateLog(GIOChannel *source,GIOCondition condition, gpointer data)
{
        gchar * msg;
        GError *pErr = NULL;
        gsize len;
        GIOStatus status;
	gchar * sBuffer;
	GtkTextIter iStart, iEnd;
	GtkTextBuffer *pTextBuffer;
	Window_Printer *TabPrinter;
	TabPrinter = (Window_Printer *) data;
 
        g_assert (condition == G_IO_IN);
        status = g_io_channel_read_line (source, &msg, &len, NULL, &pErr);
        switch (status)
        {
                case G_IO_STATUS_NORMAL:
				/* Recuperation du buffer */
				g_file_get_contents("./IHM/test", &sBuffer, NULL, NULL);
				pTextBuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(TabPrinter->pTextViewLog));
				/* Suppression des données du buffer */
				gtk_text_buffer_get_start_iter(pTextBuffer, &iStart);
				gtk_text_buffer_get_end_iter(pTextBuffer, &iEnd);
				gtk_text_buffer_delete(pTextBuffer, &iStart, &iEnd);
				/* Affichage du fichier */
				gtk_text_buffer_get_start_iter(pTextBuffer, &iStart);
				gtk_text_buffer_insert(pTextBuffer, &iStart, sBuffer, -1);
				g_free(sBuffer);
                        g_debug ("data Read = '%s'", msg);
                        g_free (msg);
                        break;
 
                case G_IO_STATUS_ERROR:
                        g_assert (pErr != NULL);
                        g_error ("%s", pErr->message);
                        break;
 
                case G_IO_STATUS_EOF:
                        g_debug ("End of file detected");
                        break;
 
                case G_IO_STATUS_AGAIN:
                        g_debug ("iResource is busy, we'll try again");
                        break;
 
                default:
                        g_assert_not_reached ();
        }
}

Le soucis c'est qu'au début il actualise ma fenêtre de log une fois (normal) après il passe dans la fonction FonctionUpdateLog
J'ai le droit à :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
DEBUG: data  Read = "Salut liberforce!"
DEBUG: End of file detected

Puis si je change le fichier à la main, il ne se passe rien, il n'update plus.
J'ai l'impression qu'il exécute une fois FonctionUpdateLog et qu'il ne le fait plus après...
Est ce que tu sais pourquoi?

Encore merci pour ton aide et ton temps!

[liberforce]

Déjà je me demande comment ça peut compiler... A chaque fois que tu me donnes un exemple, ta callback qui est censée renvoyer un gboolean ne renvoie rien...

[liberforce]

Même exemple en commentant les logs pour le cas où on reçoit un EOF:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#include <glib.h>
#include <stdio.h>
 
gboolean 
FonctionUpdateLog (GIOChannel *source, 
		GIOCondition condition,
		gpointer data)
{
	gchar * msg;
	GError *pErr = NULL;
	gsize len;
	GIOStatus status;
 
	g_assert (condition == G_IO_IN);
	status = g_io_channel_read_line (source, &msg, &len, NULL, &pErr);
	switch (status)
	{
		case G_IO_STATUS_NORMAL:
			g_debug ("Data read = '%s'", msg);
			g_free (msg);
			break;
 
		case G_IO_STATUS_ERROR:
			g_assert (pErr != NULL);
			g_error ("Error: %s", pErr->message);
			break;
 
		case G_IO_STATUS_EOF:
			/* g_debug ("End of file detected"); */
			break;
 
		case G_IO_STATUS_AGAIN:
			g_debug ("Resource is busy, we'll try again");
			break;
 
		default:
			g_assert_not_reached ();
	}
 
	return TRUE;
}
 
 
int main (int argc,  char**argv)
{
	GMainLoop *loop;
	GIOChannel *pFichierLog;
	GError *pErr = NULL;
	pFichierLog = g_io_channel_new_file("./testfile","r",&pErr);
	g_io_add_watch (pFichierLog, G_IO_IN, FonctionUpdateLog, NULL);
	loop = g_main_loop_new (NULL, FALSE);
	g_main_loop_run (loop);
}

Si je le lance, et que dans une autre console, je rajoute du contenu dans le fichier, ça fonctionne...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
> testfile
echo -n 'salut' >> testfile
echo -n ' ' >> testfile
echo -n 'Skarsnick' >> testfile
echo -n ' !' >> testfile

Dans la console qui fait tourner le programme, j'ai bien :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
** (process:10176): DEBUG: Data read = 'salut'
** (process:10176): DEBUG: Data read = ' '
** (process:10176): DEBUG: Data read = 'Skarsnick'
** (process:10176): DEBUG: Data read = ' !'

En revanche, le programme à cause du polling prend 100% du CPU, et ça pas normal...

[Skarsnick]

Super! merci!
Nous sommes dans le même cas, si je rajoute des lignes comme tu le fais j'ai la même chose!
Par contre si je décommente la ligne de débug pour le END OF FILE, je me re-retrouve dans mon cas à savoir que la lecture ne marche qu'une seule fois.

Le soucis c'est qu'en commentant la ligne de débug du case G_IO_STATUS_EOF mon appli ne tourne plus à cause du pooling constant du fichier...
Tu as une solution?
Il n'y a pas un paramètre pour lui dire de pooler moins souvent?


Si je met un return TRUE; à la fin de la fonction, ca pool à mort
Si je met un return FALSE; ça ne passe qu'une fois...
Si je ne met aucun des deux, cela dépend de la ligne: debug end of file,
Si commenté: pool à mort, sinon une fois.


Mais bon le bon comportement est de mettre un return TRUE;
Reste à comprendre pourquoi ça pool autant

[Skarsnick]

Voilà une petite modif que propose un de mes collègues (en rouge)


Et la fonction de log:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

// LOG
gboolean FonctionUpdateLog(GIOChannel *source,GIOCondition condition, gpointer data)
{
        gchar * msg;
        GError *pErr = NULL;
        gsize len;
        GIOStatus status;
	gchar * sBuffer;
	GtkTextIter iStart, iEnd;
	GtkTextBuffer *pTextBuffer;
	Window_Printer *TabPrinter;
	TabPrinter = (Window_Printer *) data;
 
	while(gtk_events_pending())
		gtk_main_iteration();

        g_assert (condition == G_IO_IN);
        status = g_io_channel_read_line (source, &msg, &len, NULL, &pErr);
        switch (status)
        {
                case G_IO_STATUS_NORMAL:
				/* Recuperation du buffer */
				g_file_get_contents("./IHM/test", &sBuffer, NULL, NULL);
				pTextBuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(TabPrinter->pTextViewLog));
				/* Suppression des données du buffer */
				gtk_text_buffer_get_start_iter(pTextBuffer, &iStart);
				gtk_text_buffer_get_end_iter(pTextBuffer, &iEnd);
				gtk_text_buffer_delete(pTextBuffer, &iStart, &iEnd);
				/* Affichage du fichier */
				gtk_text_buffer_get_start_iter(pTextBuffer, &iStart);
				gtk_text_buffer_insert(pTextBuffer, &iStart, sBuffer, -1);
				g_free(sBuffer);
                        g_debug ("data Read = '%s'", msg);
                        g_free (msg);
                        break;
 
                case G_IO_STATUS_ERROR:
                        g_assert (pErr != NULL);
                        g_error ("%s", pErr->message);
                        break;
 
                case G_IO_STATUS_EOF:
                        g_debug ("End of file detected");
                        break;
 
                case G_IO_STATUS_AGAIN:
                        g_debug ("iResource is busy, we'll try again");
                        break;
 
                default:
                        g_assert_not_reached ();
        }
	Return TRUE;
}

Ca ne bloque plus l'affichage, et ça fait bien ce que je demande, maintenant la présence d'un while est peut être pas top mais ça marche...
T'en penses quoi?

[Skarsnick]

Même fonction en plus propre
(insertion à la fin et non recopiage intégrale + focus à la fin du texte)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
gboolean FonctionUpdateLog(GIOChannel *source,GIOCondition condition, gpointer data)
{
        gchar * msg;
        GError *pErr = NULL;
        gsize len;
        GIOStatus status;
	GtkTextIter iEnd;
	GtkTextMark *pInsert = NULL;
	GtkTextBuffer *pTextBuffer;
	Window_Printer *TabPrinter;
	TabPrinter = (Window_Printer *) data;
 
	while(gtk_events_pending())
		gtk_main_iteration();
 
        g_assert (condition == G_IO_IN);
        status = g_io_channel_read_line (source, &msg, &len, NULL, &pErr);
        switch (status)
        {
                case G_IO_STATUS_NORMAL:
			/* Recuperation du buffer */
			pTextBuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(TabPrinter->pTextViewLog));
			/* On cherche la fin du buffer */
			gtk_text_buffer_get_end_iter(pTextBuffer, &iEnd);
			/* on insert les data et on gère le scroll en bas */
			gtk_text_buffer_insert(pTextBuffer, &iEnd, msg, -1);
			pInsert = gtk_text_buffer_get_insert(pTextBuffer);
			gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(TabPrinter->pTextViewLog),pInsert,0,FALSE,1,1);
                        g_debug ("data Read = '%s'", msg);
                        g_free (msg);
                        break;
 
                case G_IO_STATUS_ERROR:
                        g_assert (pErr != NULL);
                        g_error ("%s", pErr->message);
                        break;
 
                case G_IO_STATUS_EOF:
                        //g_debug ("End of file detected");
                        break;
 
                case G_IO_STATUS_AGAIN:
                        g_debug ("iResource is busy, we'll try again");
                        break;
 
                default:
                        g_assert_not_reached ();
        }
	return TRUE;
}

J'espère que le

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
	while(gtk_events_pending())
		gtk_main_iteration();

N'a pas d'effet secondaire que je n'ai pas compris...

[gege2061]

J'espère que le

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
	while(gtk_events_pending())
		gtk_main_iteration();

N'a pas d'effet secondaire que je n'ai pas compris...

Cela permet de redonner à la main à GTK+ afin qu'il traite les différents signaux en attentent, et par conséquent de rafraichir l'affichage. Rien de gênant

[Skarsnick]

Merci

Spécialement à liberforce qui m'a bien aidé

[liberforce]

Ça ne règle malheureusement pas le problème du polling... Tu donnes plus de temps processeur à GTK, en le forçant à traiter régulièrement les messages en provenance de la pompe à événements, mais si tu lances ton appli sans rien faire, un 'top' devrait t'indiquer qu'elle consomme 100% du CPU, ce qui n'est pas bon pour une appli qui ne fait rien...

Je trouve le comportement anormal. Je ne pense pas que ce soit un bug, mais il y a sans doute quelque chose d'autre à faire, ou une explication à ce comportement. Je te conseille de poster directement sur la mailing list officielle.
http://mail.gnome.org/mailman/listin...app-devel-list