Discussion :

[erqsor]

Bonjour,

J'utilise le module réseau de Qt pour communiquer entre deux machines. L'une est un serveur gérant de multiples connexions en utilisant les signaux et slots.
L'autre est un client utilisant une bibliothèque d'affichage temps réel 3D. Dans ce client, je ne peux donc pas utiliser de signaux et slots car je gère moi même la boucle de raffraichissement de l'affichage 3D.
J'ai cependant quelques questions vis-à-vis de la "bonne manière" dont je dois utiliser les classes de Qt du réseau.
Déja pour la connexion, j'aimerai savoir comment je dois vérifier que la connexion a bien été établie. Car j'ai fait quelques tests et du coté serveur, j'obtiens un message indiquant que la connexion est effective, mais du coté client, je vérifie dans a chaque itération dans la boucle principale si le status de la connexion a changé, et j'ai remarqué que le status reste en mode "ConnectingState". Lorsque j'utilise la fonction waitForConnected, alors le status passe effectivement en mode "ConnectedState", mais je ne souhaite pas utiliser de fonctions bloquantes dans mon application client.
Par contre, le probleme le plus embetant est que dans un cas comme dans l'autre, je ne peux recevoir de données du réseau, même lors de l'envoie de données, bytesAvalaible reste à 0.
Je précise pour les septiques que j'ai créé un client alternatif de test qui utilise les signaux et slots et que j'arrive parfaitement à communiquer avec celui-ci. je n'ai donc aucuns problèmes du coté du serveur.

Ai-je oublié quelque chose ?

Voila le code que j'ai testé (il n'est pas tres propre mais c'est un code de test):
Dans la fonction de connexion:

Code :

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

1
2
3
mServerSocket->abort();
mServerSocket->connectToHost(ip, port);
mServerSocket->waitForConnected(1000);

Dans la boucle principale:

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
// Verify connexion status
static QAbstractSocket::SocketState currentSocketState = QAbstractSocket::UnconnectedState;
QAbstractSocket::SocketState lastSocketState = currentSocketState;
currentSocketState = serveur->state();
if (mConnected)
{
	if (currentSocketState == QAbstractSocket::UnconnectedState)
	{
		appendTextToLog("Déconnecté");
		deconnected();
	}
	else if (mServerSocket->isValid())
	{
		static int currentBytesAvailable = 0;
		int lastBytesAvailable = currentBytesAvailable;
		currentBytesAvailable = mServerSocket->bytesAvailable();
		if (currentBytesAvailable != lastBytesAvailable && currentBytesAvailable > 0)
			receivedData();
	}
}
else
{
	if (currentSocketState != lastSocketState)
	{
		switch(currentSocketState)
		{
			case QAbstractSocket::UnconnectedState:
				appendTextToLog("Deconnecté");
				deconnected();
				break;
			case QAbstractSocket::ConnectedState:
				appendTextToLog("Connecté");
				connected();
				break;
			case QAbstractSocket::ConnectingState:
				appendTextToLog("Connexion...");
				break;
		}
	}
}

[erqsor]

OK, j'ai réussi à me connecter correctement, mais je ne parviens pas à détecter l'arrivée de données avec la fonction waitForReadyRead. Que dois-je faire pour détecter correctement l'arrivée de données ?
Je précise que j'ai vérifié que mon programme passe bien par la fonction mServerSocket->waitForReadyRead(1).

Voici le nouveau code:

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
// Network status change
static QAbstractSocket::SocketState currentSocketState = QAbstractSocket::UnconnectedState;
QAbstractSocket::SocketState lastSocketState = currentSocketState;
currentSocketState = mServerSocket->state();
if (currentSocketState != lastSocketState)
{
	switch(currentSocketState)
	{
		case QAbstractSocket::UnconnectedState:
			appendTextToLog("Deconnecté");
			deconnected();
			break;
		case QAbstractSocket::ConnectedState:
			appendTextToLog("Connecté");
			connected();
			break;
		case QAbstractSocket::ConnectingState:
			appendTextToLog("Connexion...");
			mServerSocket->waitForConnected(1);
			break;
	}
}
// when connected
if (mConnected)
{
	if ( mServerSocket->waitForDisconnected(1) )
	{
	}
	else if ( mServerSocket->waitForReadyRead(1) )
	{
		receivedData();
	}
}

Et j'ai le meme probleme pour l'écriture de données et mServerSocket->waitForBytesWritten(1);

[erqsor]

Bon j'ai continué les tests et ca a l'air de fonctionner correctement maintenant. Dites moi si vous voyez une amélioration à apporter.
Voici le code fonctionnel:

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
// Network status change
static QAbstractSocket::SocketState currentSocketState = QAbstractSocket::UnconnectedState;
QAbstractSocket::SocketState lastSocketState = currentSocketState;
currentSocketState = mServerSocket->state();
if (currentSocketState != lastSocketState)
{
	switch(currentSocketState)
	{
		case QAbstractSocket::UnconnectedState:
			if (lastSocketState == QAbstractSocket::ConnectedState)
				display("Disconnected");
			else
				display("connexion failed");
			disconnected();
			break;
		case QAbstractSocket::ConnectedState:
			mConnected = true;
			break;
		case QAbstractSocket::ConnectingState:
			display("Connexion...");
			break;
	}
}
// when connected
if (mConnected && !mServerSocket->waitForDisconnected(0))
{
	mServerSocket->waitForReadyRead(0);
	static int currentBytesAvailable = 0;
	int lastBytesAvailable = currentBytesAvailable;
	currentBytesAvailable = mServerSocket->bytesAvailable();
	if ( currentBytesAvailable > 0 && currentBytesAvailable != lastBytesAvailable )
		dataReceived();
}

[erqsor]

Bonjour,

Il s'avère que j'ai encore un gros problème: Je peux lire le premier paquet de données arrivant dans le socket client, mais pas les suivants. Je pense donc avoir omit quelque chose pour permettre au socket de pouvoir recevoir de nouveau des données (après avoir lues celles recues), mais je ne trouve pas.
Ou alors je reçois les données alors que je suis en train de lire les précédentes, mais je ne sais pas quel est le comportement par défaut dans mon cas lorsque je n'utilise pas les signaux et slots.
Voici, en complèment du code précédant inclu dans la boucle principale, le code de lecture des données:

fonction dataReceived:

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
int nbBytesDisp = mServerSocket->bytesAvailable();
 
QDataStream ds( mServerSocket );
 
// Récupération du nombre d'octets de données dans la trame
if ( mNbBytesParams  == 0 )
{
	// Pas assez de données
	if ( nbBytesDisp < 4 )
		return;
 
	// Lecture de l'entier 32bits de la taille des parametres
	quint32 mNbBytesParams = 0;
	ds >> mNbBytesParams ;
 
	nbBytesDisp = mServerSocket->bytesAvailable();
}
 
// Pas assez de données
if ( nbBytesDisp < mNbBytesParams )
	return;
 
// Lecture des parametres
QByteArray params = mServerSocket->read( mNbBytesParams );
 
// affichage
display( mNbBytesParams  );
display( params );
 
// Taitement des données
...
 
// Reinit
mNbBytesParams = 0;
 
// Verification d'autres données
if ( mServerSocket->bytesAvailable() > 0 )
	dataReceived();

Comme vous voyez, j'ai recours à l'opérateur ">>", ainsi qu'a la fonction read. Ou alors cela peut il etre la cause du probleme ?

[erqsor]

Bonjour,

Bon n'ayant pas recu d'autres réponses succeptibles de m'aider, j'ai fait quelques tests. J'ai donc créé un nouveau projet client en mode console afin de tester le code. Et voici ma conclusion :
Les commandes waitForXxx de la classe QTcpSocket ne fonctionnent que si le signal attaché à la fonction est émis lors de l'attente dans cette fonction.

En clair dans la boucle principale de mon application graphique, si je suis en train de faire un render alors que le sianal ReadyRead est émit, la prochaine fois que la fonction waitForReadyRead sera appelée, je recevrait quand meme "false" en retour.

Ceci constaté, je cherche actuellement une autre solution. Donc si quelqu'un a une idée je suis preneur.

Voici le code de mon programme de test client si vous voulez tester (On doit taper sur la touche "Entrée" pour se connecter ou se déconnecter):

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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
#include <QtCore>
#include <QtNetwork>
 
#include <windows.h>
 
#include <iostream>
 
void connectOrDisconnect(QTcpSocket * socket)
{
	if ( socket != NULL )
	{
		if ( socket->state() == QAbstractSocket::UnconnectedState )
		{
			socket->connectToHost("localhost", 1337);
		}
		else if ( socket->state() == QAbstractSocket::ConnectedState )
		{
			socket->disconnectFromHost();
		}
		else
		{
			socket->abort();
		}
	}
}
 
int main(int argc, char *argv[])
{
	QTcpSocket * socket = new QTcpSocket;
	int stateEnter;
 
	while (1)
	{
		int lastStateEnter = stateEnter;
		stateEnter = GetKeyState(VK_RETURN);
		if ( lastStateEnter != stateEnter && GetKeyState(VK_RETURN) < 0 )
		{
			connectOrDisconnect( socket );
		}
 
		if ( socket->state() == QAbstractSocket::UnconnectedState && socket->waitForConnected(0) )
			std::cout << "disconnected" << std::endl;
		if ( socket->state() == QAbstractSocket::ConnectedState && socket->waitForDisconnected(0) )
			std::cout << "disconnected" << std::endl;
		if ( socket->waitForReadyRead(0) )
			std::cout << "ReadyRead" << std::endl;
		if ( socket->bytesAvailable() )
			std::cout << QString::number(socket->bytesAvailable()).toStdString() << " bytes available" << std::endl;
 
		switch ( socket->state() )
		{
			case QAbstractSocket::UnconnectedState:
				std::cout << "UnconnectedState" << std::endl;
				break;
			case QAbstractSocket::HostLookupState:
				std::cout << "HostLookupState" << std::endl;
				break;
			case QAbstractSocket::ConnectingState:
				std::cout << "ConnectingState" << std::endl;
				break;
			case QAbstractSocket::ConnectedState:
				std::cout << "ConnectedState" << std::endl;
				break;
			case QAbstractSocket::BoundState:
				std::cout << "BoundState" << std::endl;
				break;
			case QAbstractSocket::ClosingState:
				std::cout << "ClosingState" << std::endl;
				break;
			case QAbstractSocket::ListeningState:
				std::cout << "ListeningState" << std::endl;
				break;
			default:
				std::cout << "unknow" << std::endl;
				break;
		}
	}
}

[erqsor]

Bonjour,

J'ai commencé à étudier le système utilisé par Qt pour gérer les eventsLoop, mais c'est bien compliqué. Notamment les fonction QObject::connect et QEventLoop::processEvents. Y a t'il ici quelqu'un qui connait assez bien le fonctionnement de Qt en bas niveau pour m'aider a réaliser un système similaire et (très) simplifié dans mon event loop ?

J'ai d'ailleurs trouvé ce bout de code dans QAbstractSocket::waitForConnected. Je pense que ca pourrait etre utile pour créer mon implémentation spécifique du socket :

Code :

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

1
2
3
4
5
if (d->socketEngine && d->socketEngine->waitForWrite(timeout, &timedOut) && !timedOut) {
            d->_q_testConnection();
        } else {
            d->_q_connectToNextAddress();
        }

Mais je ne sais pas ce que sont d et socketEngine (peut etre l'objet socket dépendant de la plateforme) ?

[yan]

Salut.
Tu n'utilise pas d'eventloop??

[erqsor]

Salut,

non je n'utilise ni eventLoop, ni les classes GUI de Qt. Et comme je n'utilise pas d'eventLoop, je ne peux utiliser les signaux.

Ca fait deja quelques jours que je cherche une solution sans succès, alors j'ai commencé à me diriger vers une solution multi-threadé pour gérer réseau (avec eventLoop de Qt) et appli 3D (avec l'eventLoop de Ogre) en parallele, mais c'est une solution temporaire et j'aimerai revenir sur une solution mono-threadée par la suite. Car sinon je perds en performances sur les mutex mises en place sur le socket... En effet je ne peux pas me permettre que mon application 3D se bloque. Meme si j'intérroge le socket, si celui-ci est deja utilisé, je dois continuer à raffraichir l'affichage 3D.
Mais tant que je n'ai pas trouvé comment faire fonctionner les sockets Qt sans eventLoop et sans utiliser les fonctions bloquantes, je reste bloqué :/

[yan]

je comprend pas bien pourquoi tu n'utilise pas l'eventloop de Qt :/

Peux tu expliquer ton problème réelle?

[erqsor]

Et bien J'utilise Ogre et ce dernier a son propre eventLoop (sous forme de frameListener). Je ne peux pas faire fonctionner les deux eventLoop en meme temps. Sauf en faisant un autre thread (comme j'ai fait) mais je ne souhaite pas que cette solution devienne définitive. Et l'eventLoop d'ogre ne possède pas de fonctionnalités pour vérifier les signaux émits par les classes.

Il y a une alternative qui supprimerait l'eventLoop de Ogre au profit de celui de Qt, mais cela signifirait que Qt gèrerait le raffraichissement de Ogre. C'est pas top en terme de performances pour une application qui sera assez lourde. De plus je souhaite créer une application facilement upgradable au fils des MAJ de Ogre, je souhaite donc garder Ogre totalement indépendant de Qt.

Ce que j'aimerai faire, au mieux, c'est mettre a jour le socket à certains endroits dans l'eventLoop d'Ogre. Par exemple bytesAvailable reste à 0 lorsque j'envoie des données au client si je n'utilise pas les signaux (ou les fonctions bloquantes qui ne m'arrangent pas plus).

[yan]

Pourquoi utiliser Qt? As tu regarder boost::asio (ou untruc comme cela)?

les socket QT sans eventloop ne marcheron pas ou alors tu va utiliser des fonciton bloquante.

En quoi un thread te pose des problèmes de perf?

[erqsor]

Mon serveur est développé entièrement sous Qt.
L'accès au socket (coté client) est géré par des mutex, et je ne peux pas me permettre de laisser se "locker" le thread de l'application 3D.

[yan]

L'accès au socket (coté client) est géré par des mutex

Pour quoi faire?
es ce que l'ajout d'un event dans l'eventloop ogre est thread safe?

[erqsor]

En faite je me suis trompé de terme, c'est pour cela que tu ne comprends pas. Il n'y a pas d'eventloop dans ogre, mais uniquement un mainloop. Je ne peux pas appeler de slots depuis le mainloop de ogre, uniquement des fonctions. Donc pas de gestion de signaux et slots. Je dois faire le boulot que fait Qt en arriere plan si je veux détecter l'émission de signaux et ainsi lancer les slots adéquats, mais c'est un peu compliqué :/

[yan]

tu pourrai faire un QObject qui contien ton mainloop et utiliser l'evntloop de Qt pour le forever
Un truc comme

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
class ogreMainLoop : public QObject
{
int timerId;
 
public :
    ogreMainLoop (QObject * parent = 0):QObject(parent)
{
     //tu peux choisir la cadence en ms de la boucle. 0 == dés que posible
     timerId = startTimer(0);
}
 
protected :
vois timerEvent (QTimerEvent * ev)
{
if(timerId == ev->timerId())
{
//ton main loop
....
}
}

[erqsor]

Hum franchement ca m'ennuie beaucoup de bidouiller l'event loop de Ogre. Je préfère laisser ogre gérer son propre timing.
Du coup tant pis, je me suis orienté sur une solution avec deux threads. On verra ce que ca donne en utilisation intensive du réseau, mais pour l'instant ca marche tres bien ainsi