multithreading et sockets

**barbug** · 02/03/2009, 18h11

Slt, j'ai fait une classe CTache, qui dérive de QThread. De celle-ci, j'en dérive une autre. Uploader. Je crée la socket dans son run() et je connecte ses signaux à des slots de Uploader. Mais en fait cette socket est totalement bidon. Elle ne marche pas, bug qt ? J'ai avant celà un thread principal qui se connecte au serveur (sur le même port). Tout se passe bien. Quand je rentre dans le run() du Uploader, il se connecte bien (le serveur reçoit bien une connection, c'est sûr) mais la socket n'emet aucuns signaux... Après, j'ai essayé d'écrire dans la socket mais elle n'envoie strictement rien... Pourquoi ?

Voici le code de ces deux classes. Si quelqu'un arrive à me sortir de ce pétrain, je le remercie, c'est pour un projet à rendre dans une semaine !

Merci d'avance !!!!

CTaches.h

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
 
 
#ifndef CTACHES_H
#define CTACHES_H
 
 
#include <QThread>
#include <QString>
#include <QtNetwork>
#include <QTcpSocket>
 
#include "CConnRapide.h"
#include "CstTransactions.h"
 
namespace Projet
{
	class CTache : public QThread
	{
		Q_OBJECT
	  protected:
		QTcpSocket* m_Socket;
		bool m_Connecte;
 
		quint64 m_IdProvisoire;
		bool m_Erreur;
		bool m_FinTransfert;
 
	  public slots:
		// Socket
		void ConnectionEtablie();
		void DonneesRecues();
		void Deconnecte();
		void ErreurSocket(QAbstractSocket::SocketError erreur);
 
	  signals:
		void AvancementFic(quint64 Id, quint64 Avancement);
		void EnvoiFini(quint64 Id);
		void ErreurTransfert(quint32 IdErr);
 
		// Debug
		void Debug(QString Str);
 
	  public:
		CTache(quint64 IdProvisoire, QObject* Parent);
 
		virtual void run() = 0;
	};// class CTache
 
 
 
	class CUploader : public CTache
	{
		Q_OBJECT
	  protected:
		QString m_Path;
 
	  public:
		CUploader(quint64 IdProvisoire, QString Path, QObject* Parent);
 
		virtual void run();
	};
}// namespace Projet
 
 
#endif

CTaches.cpp

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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
 
 
#include "CTaches.h"
 
#define PCT Projet::CTache
 
using namespace nsCst;
 
PCT::CTache(quint64 IdProvisoire, QObject* Parent) 
	: QThread(Parent)
{
 
	m_IdProvisoire = IdProvisoire;
}
 
 
 
void PCT::ConnectionEtablie()
{
	emit Debug("Tache : Connexion etablie");
	m_Connecte = true;
}// ConnectionEtablie()
 
 
 
void PCT::DonneesRecues()
{
	QTcpSocket* m_Socket = (QTcpSocket*) sender();
	quint32 Rep;
	QDataStream in(m_Socket);
	in >> Rep;
 
	if(Rep == CstBienRecu)
	{
		m_FinTransfert = true;
		emit EnvoiFini(m_IdProvisoire);
	}
	else
	{
		m_Erreur = true;
		emit ErreurTransfert(Rep);
	}
}// DonneesRecues()
 
 
 
void PCT::Deconnecte()
{
	m_FinTransfert = true;
}// Deconnecte()
 
 
 
void PCT::ErreurSocket(QAbstractSocket::SocketError erreur)
{
	emit Debug("Tache : Erreur socket");
 
	switch(erreur)
	{
		case QAbstractSocket::HostNotFoundError:
			break;
		case QAbstractSocket::ConnectionRefusedError:
			break;
		case QAbstractSocket::RemoteHostClosedError:
 
			break;
		default:
			break;
	}
	emit ErreurTransfert(666);
	m_Erreur = true;
}// ErreurSocket()
 
 
 
 
 
#undef PCT
 
 
 
 
 
 
#define PCU Projet::CUploader
 
 
PCU::CUploader(quint64 IdProvisoire, QString Path, QObject* Parent)
	: CTache(IdProvisoire, Parent)
{
	m_Path = Path;
}// CUploader
 
 
void PCU::run()
{
	m_Socket = new QTcpSocket();
		connect(m_Socket, SIGNAL(readyRead()), this, SLOT(DonneesRecues()));
		connect(m_Socket, SIGNAL(connected()), this, SLOT(ConnectionEtablie()));
		connect(m_Socket, SIGNAL(disconnected()), this, SLOT(Deconnecte()));
		connect(m_Socket, SIGNAL(error(QAbstractSocket::SocketError)),
			this, SLOT(ErreurSocket(QAbstractSocket::SocketError)));
	m_Connecte = false;
	m_FinTransfert = false;
	m_Erreur = false;
 
	m_Socket->connectToHost(CConnRapide::Get()->GetHote(), CConnRapide::Get()->GetPort());
 
	// On attends d'être connecté au serveur
	while(!m_Connecte)
	{
		emit Debug("Uploader : Nouveau tour");
		if(m_Erreur) return;
		sleep(2);
	}
	sleep(1);
 
	QFile Fic (m_Path);
	Fic.open(QIODevice::ReadOnly);
 
	quint64 Taille = Fic.size();
	{
		QByteArray paquet;
		QDataStream out(&paquet, QIODevice::WriteOnly);
 
		out << qToBigEndian(CstRqEnvFic)
			<< qToBigEndian(m_IdProvisoire)
			<< qToBigEndian(Taille);
		m_Socket->write(paquet);
	}
 
	quint64 Envoye = 0;
	while(!m_Erreur && Fic.bytesAvailable())
	{
		Envoye += m_Socket->write(Fic.read(50000));
		emit AvancementFic(m_IdProvisoire, Envoye);
	}
 
	// On attends que le serveur nous dise qu'il ait bien tout reçu
	while(!m_FinTransfert) if(m_Erreur) return;
 
}// run()
 
 
 
#undef PCU

Encore merci !

**IrmatDen** · 02/03/2009, 20h20

Comme cela t'a déjà été dit et répété: pas de signaux/slots sans boucle d'événements. Les sockets ainsi que leur système n'y fait pas exception.

**barbug** · 02/03/2009, 20h39

OK, merci, je vais essayer ça. Mais seulement, je me disais que pour l'envoi du fichier, il etait interessant de le mettre dans le run et qu'un signal le bloc si le serveur coupe la socket ou qu'il y une erreur, etc... Comment faire cela dans ce cas ? Car si je me mets dans un slot, un autre slot ne sera pas appelé !

Merci d'avance !

**IrmatDen** · 02/03/2009, 20h43

Les classes réseaux fonctionnent de façon asynchrone, et les sockets émettent des erreurs par signal, il te faut y connecter un slot pour les détecter et réagir en conséquence.