Discussion :

[barbug]

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]

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]

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]

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.

[barbug]

Oui mais si le thread est occupé à envoyer le fichier, il ne recevra pas les signaux ! Si ?

[IrmatDen]

Pas si tu l'envoies d'un bloc, faut envoyer par paquet.

[yan]

Tu pourrais plus simplement créé une class qui gère ces connect en interne. En gros ce que tu as fait avec le thread mais dans une classe et sans boucle while.
Pour émuler ta boucle d'envoi de paquet, je te conseillerai d'utiliser un slot et la fonction static QTimer::singleShot avec un temps à 0.
http://qt.developpez.com/doc/4.4/qtimer/#singleshot
Histoire de faire fonctionner l'eventloop en parallèle.

De plus, une classe comme cela pourra aussi être utiliser dans une thread avec eventloop.

Juste pour info, dans le code que tu as montré à une erreur d'accés concurrent au socket:
Une QThread n'appartiens pas au thread que tu créé.
Le socket est créé dans le run et appartiens au thread.
Un slot est éxécuter dans le thread possédant l'objet => tes slot ne sont pas éxécuté dans le thread que tu créé.

[barbug]

Je vais essayer cette technique. Merci

par contre, j'ai remarqué que j'écris trés vite sur la socket. Et quand j'ai finis d'écrire, il est trés loin d'avoir fini d'envoyer, est-ce normal ? j'ai pensé à un buffer et j'ai donc ajouté :

m_Socket->waitForBytesWritten(10000);

C'est moins pire mais pas encore parfait. Il m'affiche 100% alors qu'il continue à envoyer (vérifié avec wireshark !)

Comme empécher ça ?

Merci d'avance !

[barbug]

C'est bon, j'ai trouvé une solution qui semble marche !

Merci beaucoup !!!!

[IrmatDen]

Et quand j'ai finis d'écrire, il est trés loin d'avoir fini d'envoyer, est-ce normal ?

Oui c'est normal, ton HDD ou ta clé USB ont un bien meilleur débit que la plupart des connexions réseaux (oserais-je dire "toute"...)

[barbug]

Oui mais moi mon but etait de savoir combien il avait réellement envoyé. j'ai donc arrété d'ajouter dans la socket tant qu'il n'avait pas tout envoyé et ça a l'air de marcher.

Merci encore !