Asio : TCP Async_read

Version imprimable

Bonjour bonjour, j'ai (encore et toujours) des problèmes avec Asio :oops:

Je m'explique : j'ai lu et me suis inspiré de l'article de Pierre Schwartz (http://khayyam.developpez.com/articl.../architecture/), et je suis en train de réaliser un jeu comportant un serveur, qui ne fait que ça (et non, comme dans l'article, un client qui joue aussi le rôle de serveur), et des clients qui s'y connectent. Autant pour le serveur que pour le client, j'utilise ceci pour mettre en place l'écoute sur le socket TCP, en ayant vérifié que le socket soit bien connecté avant :
Code:

1 2 3 m_tcpSocket->async_receive(asio::buffer(m_networkBuffer), boost::bind(&NetworkMachine::tcpAsyncReceive, this, asio::placeholders::error, asio::placeholders::bytes_transferred)); asio::thread(boost::bind(&asio::io_service::run, &m_io));
Ensuite, ma fonction tcpAsyncReceive :
Code:

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 void NetworkMachine::tcpAsyncReceive(const asio::error_code& pE, size_t pBytesReceived) { std::cout << "tcpAsyncReceive size : " << m_networkBuffer.size() << std::endl; std::cout << "pE.value() : " << pE.value() << std::endl; if (pE.value() != 0) { EngineEvent e; e.m_type = EngineEvent::REMOVE_MACHINE; e.m_iData["ID"] = m_id; m_parent->pushReceivedEvent(e); return; } // let's deserialize the message if (m_networkBuffer.size() > 0) { std::string strData(&m_networkBuffer[0], m_networkBuffer.size()); std::istringstream archiveStream(strData); boost::archive::text_iarchive archive(archiveStream); EngineEvent ne; archive >> ne; // add the event to the received event queue m_parent->pushReceivedEvent(ne); std::cout << "Something received from " << getNick() << " and added to NetworkEngine received queue." << std::endl; } return; }
J'ai bien d'affiché "tcpAsyncReceive size : 0", 0 erreurs une première fois à l'établissement de la connexion, puis... Plus rien, alors que le client continue d'émettre des données, et que le socket n'est pas fermé (Ce que je sais pour la simple et bonne raison que si je quitte le serveur, le client me dit qu'il est déconnecté, mais pas avant).

Ma question est donc, ai-je oublié quelque chose ? Faut-il remettre en place l'écoute après que la fonction ait été appellée une fois ?

Merci.

22/01/2009, 16h58
Mat007

Salut,

A vue de nez je dirais qu'il faut re-demander à recevoir après avoir reçu quelque chose.

MAT.
22/01/2009, 17h02
Kernald

C'est à dire, mettre m_tcpSocket->async_receive(asio::buffer(m_networkBuffer), boost::bind(&NetworkMachine::tcpAsyncReceive, this, asio::placeholders::error, asio::placeholders::bytes_transferred));
à la fin de tcpAsyncReceive ?
22/01/2009, 17h09
Alp

Ne serait-ce pas approprié d'avoir un thread qui s'occupe de boucler en lisant s'il y a quelque chose à lire, puis qui attend par exemple 50ms avant de retourner voir. Dès qu'il y a quelque chose, il récupère, et il met dans un conteneur de messages, qui sera traité et vidéo au fur et à mesure par le thread principal ?

Parce que là, ta solution amènerait à un appel récursif dont on ne peut dire s'il termine (si tu modifies encore ta fonction).
22/01/2009, 17h16
Kernald

Citation:

Envoyé par Alp

Ne serait-ce pas approprié d'avoir un thread qui s'occupe de boucler en lisant s'il y a quelque chose à lire, puis qui attend par exemple 50ms avant de retourner voir. Dès qu'il y a quelque chose, il récupère, et il met dans un conteneur de messages, qui sera traité et vidéo au fur et à mesure par le thread principal ?

N'est-ce pas ce qui est fait avec m_tcpSocket->async_receive(asio::buffer(m_networkBuffer), boost::bind(&NetworkMachine::tcpAsyncReceive, this, asio::placeholders::error, asio::placeholders::bytes_transferred)); ? (Je ne connais pas encore vraiment Asio, donc j'essaie...)
22/01/2009, 17h23
Alp

Moui.

Je viens de retrouver cet exemple qui devrait bien t'aider : http://www.boost.org/doc/libs/1_37_0...hat_server.cpp
22/01/2009, 18h21
Kernald

Le problème c'est que je fais quasiment la même chose que sur l'exemple justement, sauf que j'ai tout regroupé en une seule fonction... J'ai essayé de remettre le async_receive à la fin de ma fonction : sur le client ça marche, sans soucis, mais sur le serveur... Elle est bien appelée en boucle dès la première réception :/
22/01/2009, 18h49
Alp

Justement il ne faut pas le faire en une fonction !
Boost a fait en sorte que tu confies, pour la réception depuis un socket, la gestion d'erreur à une fonction et la gestion de récupération du contenu à une autre. Garde cette séparation et fais vraiment comme ils font eux, ça ira ;)

Ok, j'essaie ça et je te dis ;)

Edit : non, ça boucle toujours... V'la le code :

Code:

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
 
void NetworkMachine::tcpAsyncReceive(const asio::error_code& pE, size_t pBytesReceived) {
	std::cout << "tcpAsyncReceive" << std::endl;
	if (pE.value() != 0) {
		EngineEvent e;
		e.m_type = EngineEvent::REMOVE_MACHINE;
		e.m_iData["ID"] = m_id;
		m_parent->pushReceivedEvent(e);
		return;
	}
	m_tcpSocket->async_receive(asio::buffer(m_networkBuffer), boost::bind(&NetworkMachine::tcpAsyncReceiveD, this, asio::placeholders::error, asio::placeholders::bytes_transferred));
}
 
void NetworkMachine::tcpAsyncReceiveD(const asio::error_code& pE, size_t pBytesReceived) {
	std::cout << "tcpAsyncReceiveD" << std::endl;
	if (pE.value() != 0) {
		return;
	}
	// let's deserialize the message
	if (m_networkBuffer.size() > 0) {
		std::string strData(&m_networkBuffer[0], m_networkBuffer.size());
		std::istringstream archiveStream(strData);
		boost::archive::text_iarchive archive(archiveStream);
 
		EngineEvent ne;
		archive >> ne;
 
		// add the event to the received event queue
		m_parent->pushReceivedEvent(ne);
		std::cout << "Something received from " << getNick() << " and added to NetworkEngine received queue." << std::endl;
	}
	m_tcpSocket->async_receive(asio::buffer(m_networkBuffer), boost::bind(&NetworkMachine::tcpAsyncReceive, this, asio::placeholders::error, asio::placeholders::bytes_transferred));
}

Dès réception du premier paquet, tcpAsyncReceive tcpAsyncReceiveD en continu, je vois pas quoi faire de plus :/

22/01/2009, 19h40
Alp

Pourquoi refais-tu un async_receive dans la deuxième fonction ?
Il ne faut pas.

C'est pourtant ce qui est fait sur l'exemple que tu as linké, si je me trompe pas :

Code:

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
 
  void handle_read_header(const boost::system::error_code& error)
  {
    if (!error && read_msg_.decode_header())
    {
      boost::asio::async_read(socket_,
          boost::asio::buffer(read_msg_.body(), read_msg_.body_length()),
          boost::bind(&chat_session::handle_read_body, shared_from_this(),
            boost::asio::placeholders::error));
    }
    else
    {
      room_.leave(shared_from_this());
    }
  }
 
  void handle_read_body(const boost::system::error_code& error)
  {
    if (!error)
    {
      room_.deliver(read_msg_);
      boost::asio::async_read(socket_,
          boost::asio::buffer(read_msg_.data(), chat_message::header_length),
          boost::bind(&chat_session::handle_read_header, shared_from_this(),
            boost::asio::placeholders::error));
    }
    else
    {
      room_.leave(shared_from_this());
    }
  }

Et, si je ne le mets pas sur la deuxième, toutes les données reçues iront sur la deuxième, non ?

22/01/2009, 20h08
Mat007

Peut-être qu'il faut utiliser async_read, genre comme dans l'exemple, plutôt que d'aller taper directement dans le async_receive de la socket ?
En tous cas c'est comme ça que je procède systématiquement pour du TCP.

MAT.
22/01/2009, 20h33
Kernald
En utilisant ceci :
Code:

1 2 3 4 5 6 asio::async_read(m_tcpSocket, asio::buffer(m_networkBuffer), boost::bind(&NetworkMachine::tcpAsyncReceive, this, asio::placeholders::error, asio::placeholders::bytes_transferred));
Je me retrouve avec des erreurs de compilations plutôt obscures...

Citation:

Envoyé par G++

/usr/include/asio/impl/read.ipp: In function ‘void asio::async_read(AsyncReadStream&, const MutableBufferSequence&, CompletionCondition, ReadHandler) [with AsyncReadStream = asio::basic_stream_socket<asio::ip::tcp, asio::stream_socket_service<asio::ip::tcp> >*, MutableBufferSequence = asio::mutable_buffers_1, CompletionCondition = asio::detail::transfer_all_t, ReadHandler = boost::_bi::bind_t<void, boost::_mfi::mf2<void, NetworkMachine, const asio::error_code&, long unsigned int>, boost::_bi::list3<boost::_bi::value<NetworkMachine*>, boost::arg<1> (*)(), boost::arg<2> (*)()> >]’:
/usr/include/asio/impl/read.ipp:211: instantiated from ‘void asio::async_read(AsyncReadStream&, const MutableBufferSequence&, ReadHandler) [with AsyncReadStream = asio::basic_stream_socket<asio::ip::tcp, asio::stream_socket_service<asio::ip::tcp> >*, MutableBufferSequence = asio::mutable_buffers_1, ReadHandler = boost::_bi::bind_t<void, boost::_mfi::mf2<void, NetworkMachine, const asio::error_code&, long unsigned int>, boost::_bi::list3<boost::_bi::value<NetworkMachine*>, boost::arg<1> (*)(), boost::arg<2> (*)()> >]’
network_machine.cpp:41: instantiated from here
/usr/include/asio/impl/read.ipp:200: erreur: request for member ‘async_read_some’ in ‘s’, which is of non-class type ‘asio::basic_stream_socket<asio::ip::tcp, asio::stream_socket_service<asio::ip::tcp> >*’
22/01/2009, 23h25
Mat007

Tu utilises quelle version de boost ?
Pourquoi c'est asio:: et non boost::asio:: tiens d'ailleurs ?

MAT.
23/01/2009, 06h07
Kernald

J'ai Boost 1.35, et je pense que je viens de trouver la cause de pas mal de soucis... J'ai aussi Asio 1.1.0, alors qu'Asio fait maintenant partie de Boost, je devrais pas en avoir besoin je me trompe ?
23/01/2009, 10h30
Mat007

Asio fait partie de boost depuis justement la version 1.35 donc oui en effet tu devrais utiliser boost/asio et boost::asio plutôt.

MAT.
23/01/2009, 10h33
Alp

Au passage, récupère la 1.37. Parce que par exemple je me suis basé sur sa doc pour les exemples donnés etc.
23/01/2009, 18h10
Kernald

En effet, j'ai de jolis conflits entre Asio et Boost::asio en fait... Je fais du ménage, et je vous donne des nouvelles ^^

Voilà, j'ai donc viré Asio, et mit Boost en 1.37. Je compile avec ma ligne d'avant, les deux fonctions sont appelées en boucle.
J'essaie donc avec
Code:

1 2 3 4 5 6 boost::asio::async_read(m_tcpSocket, boost::asio::buffer(m_networkBuffer), boost::bind(&NetworkMachine::tcpAsyncReceive, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
et GCC me répond toujours de manière barbare... :

Citation:

Envoyé par GCC

/usr/include/boost/asio/impl/read.ipp: In function ‘void boost::asio::async_read(AsyncReadStream&, const MutableBufferSequence&, CompletionCondition, ReadHandler) [with AsyncReadStream = boost::asio::basic_stream_socket<boost::asio::ip::tcp, boost::asio::stream_socket_service<boost::asio::ip::tcp> >*, MutableBufferSequence = boost::asio::mutable_buffers_1, CompletionCondition = boost::asio::detail::transfer_all_t, ReadHandler = boost::_bi::bind_t<void, boost::_mfi::mf2<void, NetworkMachine, const boost::system::error_code&, long unsigned int>, boost::_bi::list3<boost::_bi::value<NetworkMachine*>, boost::arg<1> (*)(), boost::arg<2> (*)()> >]’:
/usr/include/boost/asio/impl/read.ipp:232: instantiated from ‘void boost::asio::async_read(AsyncReadStream&, const MutableBufferSequence&, ReadHandler) [with AsyncReadStream = boost::asio::basic_stream_socket<boost::asio::ip::tcp, boost::asio::stream_socket_service<boost::asio::ip::tcp> >*, MutableBufferSequence = boost::asio::mutable_buffers_1, ReadHandler = boost::_bi::bind_t<void, boost::_mfi::mf2<void, NetworkMachine, const boost::system::error_code&, long unsigned int>, boost::_bi::list3<boost::_bi::value<NetworkMachine*>, boost::arg<1> (*)(), boost::arg<2> (*)()> >]’
network_machine.cpp:75: instantiated from here
/usr/include/boost/asio/impl/read.ipp:216: erreur: request for member ‘get_io_service’ in ‘s’, which is of non-class type ‘boost::asio::basic_stream_socket<boost::asio::ip::tcp, boost::asio::stream_socket_service<boost::asio::ip::tcp> >*’
/usr/include/boost/asio/impl/read.ipp:232: instantiated from ‘void boost::asio::async_read(AsyncReadStream&, const MutableBufferSequence&, ReadHandler) [with AsyncReadStream = boost::asio::basic_stream_socket<boost::asio::ip::tcp, boost::asio::stream_socket_service<boost::asio::ip::tcp> >*, MutableBufferSequence = boost::asio::mutable_buffers_1, ReadHandler = boost::_bi::bind_t<void, boost::_mfi::mf2<void, NetworkMachine, const boost::system::error_code&, long unsigned int>, boost::_bi::list3<boost::_bi::value<NetworkMachine*>, boost::arg<1> (*)(), boost::arg<2> (*)()> >]’
network_machine.cpp:75: instantiated from here
/usr/include/boost/asio/impl/read.ipp:221: erreur: request for member ‘async_read_some’ in ‘s’, which is of non-class type ‘boost::asio::basic_stream_socket<boost::asio::ip::tcp, boost::asio::stream_socket_service<boost::asio::ip::tcp> >*’
make: *** [network_machine.o] Erreur 1

Au temps pour moi, j'avais pas remarqué la p'tite étoile... J'ai donc ça maintenant :
Code:

1 2 3 4 5 6 boost::asio::async_read((*m_tcpSocket), boost::asio::buffer(m_networkBuffer), boost::bind(&NetworkMachine::tcpAsyncReceive, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
Qui se compile, s'exécute... Et boucle toujours :/

24/01/2009, 20h25
Mat007

C'est quoi le type de m_networkBuffer ?
(Au passage tu as bien un buffer de réception par client ?)
C'est voulu si tu ne donnes pas la taille des données attendues en faisant le async_read ?

MAT.
29/01/2009, 13h10
Kernald

Désolé pour le délai, j'ai eu des soucis de courant et de téléphone depuis samedi, récupérés ce matin.

m_networkBuffer est un std::vector<char>, j'en ai bien un par client. Cependant, je ne comprends pas trop ce que tu entends par la taille des données attendues ?

Si tu veux jeter un oeil, je risque de pas être trop présent dans les quelques jours qui viennent, la source est dispo ici : http://code.google.com/p/mgep/source/browse/trunk/ (Serveur/CommunicationClients et Client/CommunicationServeur)

À la prochaine,

Marc
29/01/2009, 13h46
Mat007

Lors de la construction du asio::buffer tu utilises cette primitive.
Comme ton vecteur est vide, ça fait un buffer vide et ça explique qu'il soit considéré comme "prêt" tout de suite, d'où déclenchement de la callback tout de suite, etc...

En général on commence par lire l'entête du message (d'une certaine taille fixe connue à l'avance donc) qui contient la taille des données à lire ensuite.
C'est d'ailleurs ce qui est fait dans l'exemple du serveur de chat.

MAT.
29/01/2009, 14h26
Kernald

Ok, je vois le problème... Il y a un moyen de considérer le buffer comme prêt uniquement si il contient plus de X octets ?
29/01/2009, 19h08
Mat007

Je ne crois pas non, juste lorsque le buffer contient exactement X octets.
Ça ne serait pas très pratique de savoir qu'il contient au moins X octets puisqu'il faudra de toute façon un moyen de tester si tout est là avant de pouvoir en faire quelque chose.

MAT.
29/01/2009, 21h58
Kernald

Ben, je voudrais uniquement tester que le buffer ne soit pas vide, pour éviter l'appel en boucle justement. Sinon, je ne vois pas trop comment faire...
29/01/2009, 22h12
Mat007

C'est normal que ça boucle, il faut bien recommencer à lire après avoir reçu et traité un message.

Tu fais un premier async_read avec comme taille de buffer par exemple sizeof( std::size_t ) dans lequel tu lis la taille du message à venir dans une première callback.
Puis tu fais un autre async_read avec comme taille de buffer la taille que tu viens de lire dans l'entête pour recevoir le contenu utile du message dans une seconde callback.
Ensuite tu traites ton message et une fois que c'est fait tu te remets en attente de lecture d'un nouvel entête en rappelant le premier async_read.

Bien sûr de l'autre côté lors de l'envoi il faut que tu commences par écrire la taille du message (un std::size_t donc) puis ensuite le contenu utile du message.

C'est fait comme ça dans l'exemple d'ailleurs si je ne m'abuse.

MAT.
30/01/2009, 08h59
Kernald

Ok, côté client, j'envoie ça en un seul paquet avec un caractère de séparation ou une taille précise pour l'entête, ou en deux paquets séparés ?

Edit : j'ai fait un petit test en remplissant le buffer avant d'appeller async_read... En effet la fonction n'est plus appelée en boucle, mais à chaque fois qu'elle est appelée, elle ne contient pas ce qui a été reçu, mais ce avec quoi j'ai rempli le buffer au début... Alors que ça devrait avoir été remplacé, non ? J'ai essayé de mettre un m_networkBuffer.clear(), mais rien à faire, je "reçois" toujours le même caractère... Je commence à désespérer :/

Re edit : visiblement, j'ai (un peu) moins de soucis avec un boost::array<1024, char>, et je viens de m'appercevoir que c'est aussi ce que j'utilise pour le client, je vais me pencher là dessus... Pas mal de segfaults dont je sais pas d'où elles viennent, mais ça va aller :/

Bon, ben voilà, résolu avec un boost::array<1024, char> comme m_networkBuffer. Voilà ma fonction de réception, au final :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
void NetworkMachine::tcpAsyncReceive(const boost::system::error_code& pE, size_t pBytesReceived) {
	if (pE.value() != 0) {
		// Erreur, on déconnecte le client
	}
	// Le message a bien été reçu
	if (pBytesReceived > 0) {
		// On le traite
	}
	// Et on remet le socket en écoute
	m_tcpSocket->async_receive(boost::asio::buffer(m_networkBuffer), boost::bind(&NetworkMachine::tcpAsyncReceive, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
}

Voili voilà, merci pour l'aide encore une fois ;)